********************************先看程式碼後面解釋********************************

#神經網路演算法（Neural Network）
import numpy as np

def tanh(x):  #雙曲函式
    return np.tanh(x)

def tanh_deriv(x):  #雙曲函式的導數
    return 1.0 - np.tanh(x)*np.tanh(x)


def logistic(x):  #邏輯函式
    return 1/(1 + np.exp(-x))


def logistic_derivative(x):   #邏輯函式的導數
    return logistic(x)*(1-logistic(x))

class NeuralNetwork:   #定義一個神經網路的類
    def __init__(self, layers, activation='tanh'):#不指名activation=是預設為'tanh'
        """
        layers：（list）每層裡面以後多少個神經元，幾個數字就對應幾層，每個數字
            的值就對應有多少個神經元，最少要有兩層
        self相當於java中的this
        activation-->>啟用函式
        """
        if activation == 'logistic':
            self.activation = logistic    #給邏輯函式取名為logistic
            self.activation_deriv = logistic_derivative  #給邏輯函式的導數取名為logistic
        elif activation == 'tanh':
            self.activation = tanh         #給雙曲函式取名為tanh
            self.activation_deriv = tanh_deriv      #給雙曲函式的導數取名為tanh_deriv

        self.weights = []  #定義一個空的權重list
        #初始化權重的賦值
        for i in range(1, len(layers) - 1):
            """
            隨機產生權重 
                       從第二層i開始：對i層的上一層（i-1）和i層的下一層（i+1）,進行賦值
            """
            #i層和i-1層的隨機賦值
            self.weights.append((2 * np.random.random((layers[i - 1] + 1, layers[i] + 1)) - 1) * 0.25)
            #i層和i+1層的隨機賦值
            self.weights.append((2 * np.random.random((layers[i] + 1, layers[i + 1])) - 1) * 0.25)
    def fit(self, X, y, learning_rate=0.2, epochs=10000): #learning_rate學習率，epochs=10000：迴圈的次數
        X = np.atleast_2d(X)#X為訓練集，通常為二維的矩陣。
        temp = np.ones([X.shape[0], X.shape[1]+1]) #對偏向的初始化（X.shape[0]為行數，X.shape[1]為列數）
        temp[:, 0:-1] = X  #(:意思是取所有的行)
        X = temp
        y = np.array(y)

        for k in range(epochs):  #epochs=10000迴圈的次數
            i = np.random.randint(X.shape[0])
            a = [X[i]]   #隨機抽取一個數

            for l in range(len(self.weights)):     #完成正向的所有更新
                a.append(self.activation(np.dot(a[l], self.weights[l])))  #對應相乘然後相加
            error = y[i] - a[-1]  # 實際的值減去預測的值
            deltas = [
                error * self.activation_deriv(a[-1])]  # 根據與輸出層算出的誤差，反向更新

            # Staring backprobagation
            for l in range(len(a) - 2, 0, -1):  # 我們需要從第二層開始到最後一層
                deltas.append(deltas[-1].dot(self.weights[l].T) * self.activation_deriv(a[l]))#更新隱藏層Error
            deltas.reverse()   #顛倒順序
            for i in range(len(self.weights)):
                layer = np.atleast_2d(a[i])
                delta = np.atleast_2d(deltas[i])
                self.weights[i] += learning_rate * layer.T.dot(delta)  #權重更新(演算法在CSDN上：神經網路演算法1)
    def predict(self, x):
        x = np.array(x)
        temp = np.ones(x.shape[0]+1)
        temp[0:-1] = x
        a = temp
        for l in range(0, len(self.weights)):
            a = self.activation(np.dot(a, self.weights[l]))
        return a

#神經網路演算法下
import numpy as np
nn = NeuralNetwork([2,2,1],'tanh')
x = np.array([[0,0],[0,1],[1,0],[1,1]])
y = np.array([0,1,1,0])
nn.fit(x,y)
for i in [[0,0],[0,1],[1,0],[1,1]]:
    print(i,nn.predict(i))
 

執行的結果為：

1.看執行的結果可以得到：

y = np.array([0,1,1,0])

     第一個值為：0，  執行結果的第一行就近似為0

     第一個值為：1，  執行結果的第二行就近似為1

     第一個值為：1，  執行結果的第三行就近似為1

     第一個值為：0，  執行結果的第四行就近似為0

    就可以看出預測的成功，如果你把程式碼裡面的

y = np.array([0,1,1,0])

    改為：[1,0,0,1]    結果就會和料想的一樣：會有四個近似的值1,0,0,1