在這個目錄下面的上一篇文章里面寫了，對于一個數據集，如何用邏輯回歸的方式去給他們分類。（鏈接 ： http://www.lxweimin.com/p/5ae1399a512b）同樣對于這個數據集，這篇文章寫的是用一個神經網絡的方式去給他們分類。

寫在前面

1. 對于下面關于神經網絡的公式推導和計算的符號表示，我參考的是吳恩達的deeplearning 的視頻里面的符號表示。如果看不懂的話，可以去cousera上或網易云課堂上面看它的課程。

2. 對于神經網絡，有很多現成的框架和庫，可以很方便的幫助你使用。但是我這幾篇文章的想法都是自己去實現這個網絡，不用框架和庫函數。對于一個初學者，我認為這樣有助于我理解這個網絡的細節。

3. 在實現的過程中，我盡可能的使用了向量化的方式去實現矩陣計算。雖然被老是被矩陣的維度搞昏，當這應該是一個好習慣。向量化的矩陣計算，不僅可以計算的更快，而且還提高了代碼的可讀性。

神經網絡的結構

數據集的結構，如下圖，（第一列和第二列表示對應的輸入，第三列表示輸出）：

image.png

設計的網絡的結構如下：

image.png

PS :

z1，z2，z3 畫圖的時候，這里有一點錯誤，應該寫成z11，z12，z13
第一個1表示是第一層的輸入，第二個1，2，3表示的是第一層的第一個，第二個，第三個結點

z1^[2] ,應該寫成z21，表示的是第二層的第一個結點的輸入，a1^[2] 表示的是第二層第一個節點的輸出

推理過程

微信圖片_20170914152329.jpg

微信圖片_20170914152509.jpg

源碼

"""
實現一個三層的神經網絡 
一個輸入層，一個輸出層，隱層有3個結點

數據集同樣也是tesetSet的數據集，和邏輯回歸的數據集是同一個，格式如下：
   x1           x2      y
   -0.017612    14.053064   0
   ....

"""
import numpy as np
from numpy import random
import matplotlib.pyplot as plt

alpha=0.01


#加載數據集，原來的數據在文件排列是按行排列
#為了計算需要，將原來的數據加載到了矩陣之后，給矩陣裝置了，是數據變成按列排列
def loadDataset():
    data=[]
    label=[]
    f=open("textSet.txt")
    for line in f:
        lineArr=line.strip().split()
        data.append( [float(lineArr[0]),float(lineArr[1]) ] ) 
        label.append(float(lineArr[2]))
    mdata=np.array(data)
    mlabel=np.array(label)
    return mdata.T,mlabel.T 



def sigmod(inX):
    return 1.0/(1+np.exp(-inX))


#激活函數的倒數
def sigmod_diff(inX):
    return sigmod(inX) * (1-sigmod(inX))



def get_z1(inputs,mlabel,weights_layer1,b1,weights_layer2,b2):  
    z1=np.dot(weights_layer1,inputs)+b1
    return z1

def get_a1(inputs,mlabel,weights_layer1,b1,weights_layer2,b2):
    z1=np.dot(weights_layer1,inputs)+b1
    a1=sigmod(z1)
    return a1


def forward(inputs,mlabel,weights_layer1,b1,weights_layer2,b2):
    #從輸入層到隱層
    z1=np.dot(weights_layer1,inputs)+b1
    a1=sigmod(z1)

    #從隱層到輸出層
    z2=np.dot(weights_layer2,a1)+b2
    a2=sigmod(z2)   
    
    #error
    dz2=a2-mlabel
    return dz2

#計算cost，每一次迭代之后，都算一下cost，看看cost是否在減小
def cost(inputs,mlabel,weights_layer1,b1,weights_layer2,b2):
    nx,m=inputs.shape
    #從輸入層到隱層
    z1=np.dot(weights_layer1,inputs)+b1
    a1=sigmod(z1)

    #從隱層到輸出層
    z2=np.dot(weights_layer2,a1)+b2
    a2=sigmod(z2)   
    
    #cost
    cost=-mlabel* np.log(a2)-(a2-mlabel)*np.log(1-a2)
    return np.sum(cost)/m


#將訓練的輸出和真實的結果show出來
def show1(inputs,mlabel,weights_layer1,b1,weights_layer2,b2):
    nx,m=inputs.shape
    #從輸入層到隱層
    z1=np.dot(weights_layer1,inputs)+b1
    a1=sigmod(z1)

    #從隱層到輸出層
    z2=np.dot(weights_layer2,a1)+b2
    a2=sigmod(z2)   
    
    plt.plot(mlabel)
    plt.plot(a2[0])
    plt.show()
    

def show2(inputs,mlabel,weights_layer1,b1,weights_layer2,b2):
    nx,m=inputs.shape
    #從輸入層到隱層
    z1=np.dot(weights_layer1,inputs)+b1
    a1=sigmod(z1)

    #從隱層到輸出層
    z2=np.dot(weights_layer2,a1)+b2
    a2=sigmod(z2)   
    
    new_a2=[]
    for i in a2[0]:
        #這里用0.1和0.9，是為了避免和mlabel畫出來的線重合
        if i <0.5:
            new_a2.append(0.1)
        if i>=0.5:
            new_a2.append(0.9)
    
    plt.plot(mlabel)
    plt.plot(new_a2)
    plt.show()



#正向傳播和反向傳播
def gradientdesc(mdata,mlabel,weights_layer1,b1,weights_layer2,b2):
    nx,m=mdata.shape
    #調用正向傳播的函數，得到dz2
    dz2=forward(mdata,mlabel,weights_layer1,b1,weights_layer2,b2)
    
    #求dw2和db2
    a1=get_a1(mdata,mlabel,weights_layer1,b1,weights_layer2,b2)
    dw2 = (1/float(m)) * np.dot(dz2,a1.T)
    db2 = (1/float(m)) * np.sum(dz2)

    #求dw1和db1
    z1=get_z1(mdata,mlabel,weights_layer1,b1,weights_layer2,b2)
    dz1 =np.dot(weights_layer2.T,dz2) * sigmod_diff(z1)
    
    dw1 = (1/float(m)) * np.dot(dz1,mdata.T)
    db1 = (1/float(m)) * np.sum(dz1)    
    
    #更新w1,w2,b1,b2
    weights_layer1=weights_layer1 - alpha * dw1
    weights_layer2=weights_layer2 - alpha * dw2
    b1=b1-alpha*db1
    b2=b2-alpha*db2

    return weights_layer1,b1,weights_layer2,b2


def three_layer_nn(maxcycle=5000):
    mdata,mlabel=loadDataset()
    nx,m=mdata.shape    

    hiden_node=3

    #隨機初始化 權值矩陣
    weights_layer1=random.random(size=(hiden_node,nx))
    b1=random.random(size=(hiden_node,m))

    weights_layer2=random.random(size=(1,hiden_node))
    b2=random.random(size=(1,m))

    #迭代 
    for i in range(maxcycle):
        weights_layer1,b1,weights_layer2,b2=gradientdesc(mdata,mlabel,weights_layer1,b1,weights_layer2,b2)
        print (cost(mdata,mlabel,weights_layer1,b1,weights_layer2,b2))


    #show
    show2(mdata,mlabel,weights_layer1,b1,weights_layer2,b2) 

if __name__=='__main__':
    maxcycle=15000
    three_layer_nn(maxcycle)

運行的結果：
（ps：黃色的線是預測的輸出，為了黃色和藍色不覆蓋，我把黃色的輸出應該是為1的改成了0.9，應該是為0的改成了0.1）

image.png

git鏈接：
數據集和代碼都在里面 https://github.com/zhaozhengcoder/Machine-Learning/tree/master/three-layer-nn