轉載於：http://blog.csdn.net/miangangzhen/article/details/51281989

#!usr/bin/env python3  
# -*- coding:utf-8 -*-  
import numpy as np  
import math  
  
# definition of sigmoid funtion  
# numpy.exp work for arrays.  
def sigmoid(x):  
    return 1 / (1 + np.exp(-x))  
  
  
# definition of sigmoid derivative funtion  
 

# input must be sigmoid function‘s result  
def sigmoid_output_to_derivative(result):  
    return result*(1-result)  
  
  
# init training set  
def getTrainingSet(nameOfSet):  
  
    setDict = {  
        "sin": getSinSet(),  
        }  
  
    return setDict[nameOfSet]  
  
def getSinSet():  
  
    x 
 
= 6.2 * np.random.rand(1) - 3.14  
    x = x.reshape(1,1)  
    # y = np.array([5 *x]).reshape(1,1)  
    # y = np.array([math.sin(x)]).reshape(1,1)  
    y = np.array([math.sin(x),1]).reshape(1,2)  
    return x, y  
  
  
def getW(synapse, delta):  
  
    resultList = []  
  
    # 遍歷隱藏層每個隱藏單元對每個輸出的權值，比如8個隱藏單元，每個隱藏單元對兩個輸出各有2個權值  
 

    for i in range(synapse.shape[0]):  
  
        resultList.append(  
            (synapse[i,:] * delta).sum()  
            )  
  
    resultArr = np.array(resultList).reshape(1, synapse.shape[0])  
  
    return resultArr  
  
  
def getT(delta, layer):  
  
    result = np.dot(layer.T, delta)  
    return result  
  
  
def backPropagation(trainingExamples, etah, input_dim, output_dim, hidden_dim, hidden_num):  
  
    # 可行條件  
    if hidden_num < 1:  
        print("隱藏層數不得小於1")  
        return  
  
    # 初始化網絡權重矩陣，這個是核心  
    synapseList = []  
    # 輸入層與隱含層1  
    synapseList.append(2*np.random.random((input_dim,hidden_dim)) - 1)  
    # 隱含層1與隱含層2, 2->3,,,,,,n-1->n  
    for i in range(hidden_num-1):  
        synapseList.append(2*np.random.random((hidden_dim,hidden_dim)) - 1)  
    # 隱含層n與輸出層  
    synapseList.append(2*np.random.random((hidden_dim,output_dim)) - 1)  
  
    iCount = 0  
    lastErrorMax = 99999  
  
    # while True:  
    for i in range(10000):  
          
        errorMax = 0  
  
        for x, y in trainingExamples:  
  
            iCount += 1  
            layerList = []  
  
            # 正向傳播  
            layerList.append(  
                sigmoid(np.dot(x,synapseList[0]))  
                )  
            for j in range(hidden_num):  
                layerList.append(  
                    sigmoid(np.dot(layerList[-1],synapseList[j+1]))  
                    )  
  
  
            # 對於網絡中的每個輸出單元k，計算它的誤差項  
            deltaList = []  
            layerOutputError = y - layerList[-1]  
            # 收斂條件  
            errorMax = layerOutputError.sum() if layerOutputError.sum() > errorMax else errorMax  
  
            deltaK = sigmoid_output_to_derivative(layerList[-1]) * layerOutputError  
            deltaList.append(deltaK)  
  
            iLength = len(synapseList)  
            for j in range(hidden_num):  
                w = getW(synapseList[iLength - 1 - j], deltaList[j])  
                delta = sigmoid_output_to_derivative(layerList[iLength - 2 - j]) * w  
                deltaList.append(delta)  
  
  
            # 更新每個網絡權值w(ji)  
            for j in range(len(synapseList)-1, 0, -1):  
                t = getT(deltaList[iLength - 1 -j], layerList[j-1])  
                synapseList[j] = synapseList[j] + etah * t  
  
            t = getT(deltaList[-1], x)  
            synapseList[0] = synapseList[0] + etah * t  
  
        print("最大輸出誤差:")  
        print(errorMax)  
  
        if abs(lastErrorMax - errorMax) < 0.0001:  
  
            print("收斂了")  
            print("####################")  
            break  
        lastErrorMax = errorMax           
  
  
    # 測試訓練好的網絡  
    for i in range(5):  
        xTest, yReal = getSinSet()  
          
        layerTmp = sigmoid(np.dot(xTest,synapseList[0]))  
        for j in range(1, len(synapseList), 1):  
            layerTmp = sigmoid(np.dot(layerTmp,synapseList[j]))  
  
        yTest = layerTmp  
        print("x:")  
        print(xTest)  
        print("實際的y:")  
        print(yReal)  
        print("神經元網絡輸出的y:")  
        print(yTest)  
        print("最終輸出誤差:")  
        print(np.abs(yReal - yTest))  
        print("#####################")  
          
  
    print("叠代次數:")  
    print(iCount)  
  
  
if __name__ == ‘__main__‘:  
  
    import datetime  
    tStart = datetime.datetime.now()  
  
    # 使用什麽樣的訓練樣例  
    nameOfSet = "sin"  
    x, y = getTrainingSet(nameOfSet)  
    # setting of parameters  
    # 這裏設置了學習速率。  
    etah = 0.01  
    # 隱藏層數  
    hidden_num = 2  
    # 網絡輸入層的大小  
    input_dim = x.shape[1]  
    # 隱含層的大小  
    hidden_dim = 100  
    # 輸出層的大小  
    output_dim = y.shape[1]  
      
    # 構建訓練樣例  
    trainingExamples = []  
    for i in range(10000):  
        x, y = getTrainingSet(nameOfSet)  
        trainingExamples.append((x, y))  
  
    # 開始用反向傳播算法訓練網絡  
    backPropagation(trainingExamples, etah, input_dim, output_dim, hidden_dim, hidden_num)  
  
    tEnd = datetime.datetime.now()  
  
    print("time cost:")  
    print(tEnd - tStart)  

分析：

1.正向傳播：

 for j in range(1, len(synapseList), 1):  
            layerTmp = sigmoid(np.dot(layerTmp,synapseList[j])) 

synapseList 存放的是權值矩陣
2.反向傳播

a.計算隱藏層的輸出在輸入上的誤差

def getW(synapse, delta):  
  
    resultList = []  
  
    # 遍歷隱藏層每個隱藏單元對每個輸出的權值，比如8個隱藏單元，每個隱藏單元對兩個輸出各有2個權值  
    for i in range(synapse.shape[0]):  
  
        resultList.append(  
            (synapse[i,:] * delta).sum()  
            )  
  
    resultArr = np.array(resultList).reshape(1, synapse.shape[0])  
  
    return resultArr  

比如：

神經網絡的相關知識(1.python 實現MLp)