Machine learning 教学神经网络异或函数

我想教授我的神经网络xor，共有3层： 1.具有2个神经元的输入层与具有2个神经元的下一个隐藏层完全连接 第三输出层，具有单个输出神经元。我将使用S形激活函数和梯度下降

我的问题是： 1.停止函数应该如何表述：我知道我们可以检查Itation的数量，或者检查错误是否小于某个可接受的错误，但是这个错误应该如何计算？公式是什么？输出层上计算的唯一错误？在一次教学过程中，一个样本？

---

2.偏差值是否可以小于1但大于0？一些描述告诉我们它应该始终为1，但另一些描述告诉我们它可以是这个范围内的随机数。

这里是一个带有反向传播的单隐层网络，可以自定义它来运行relu、sigmoid和其他激活的实验。经过几次实验，得出结论：使用relu时，网络性能更好，收敛更快，而使用sigmoid时，损耗值波动。这是因为“”

最终结果：

训练后获得的重量为：

nn.w1

nn.w2

我发现以下youtube系列对理解神经网络非常有帮助：

---

我所知道的和能在这个答案中解释的都很少。如果您想更好地理解神经网络，那么我建议您浏览以下链接：[cs231n:为一个神经元建模][4]

成本函数是如何计算的？对于单一样本培训？只涉及输出神经元？

import numpy as np
import matplotlib.pyplot as plt
from operator import xor

class neuralNetwork():
    def __init__(self):
        # Define hyperparameters
        self.noOfInputLayers = 2
        self.noOfOutputLayers = 1
        self.noOfHiddenLayerNeurons = 2

        # Define weights
        self.W1 = np.random.rand(self.noOfInputLayers,self.noOfHiddenLayerNeurons)
        self.W2 = np.random.rand(self.noOfHiddenLayerNeurons,self.noOfOutputLayers)

    def relu(self,z):
        return np.maximum(0,z)

    def sigmoid(self,z):
        return 1/(1+np.exp(-z))

    def forward (self,X):
        self.z2 = np.dot(X,self.W1)
        self.a2 = self.relu(self.z2)
        self.z3 = np.dot(self.a2,self.W2)
        yHat = self.relu(self.z3)
        return yHat

    def costFunction(self, X, y):
        #Compute cost for given X,y, use weights already stored in class.
        self.yHat = self.forward(X)
        J = 0.5*sum((y-self.yHat)**2)
        return J

    def costFunctionPrime(self,X,y):
        # Compute derivative with respect to W1 and W2
        delta3 = np.multiply(-(y-self.yHat),self.sigmoid(self.z3))
        djw2 = np.dot(self.a2.T, delta3)
        delta2 = np.dot(delta3,self.W2.T)*self.sigmoid(self.z2)
        djw1 = np.dot(X.T,delta2)

        return djw1,djw2


if __name__ == "__main__":

    EPOCHS = 6000
    SCALAR = 0.01

    nn= neuralNetwork()    
    COST_LIST = []

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

    for epoch in xrange(1,EPOCHS):
        cost = 0
        for i in inputs:
            X = i #inputs
            y = xor(X[0][0],X[0][1])
            cost += nn.costFunction(X,y)[0]
            djw1,djw2 = nn.costFunctionPrime(X,y)
            nn.W1 = nn.W1 - SCALAR*djw1
            nn.W2 = nn.W2 - SCALAR*djw2
        COST_LIST.append(cost)

    plt.plot(np.arange(1,EPOCHS),COST_LIST)
    plt.ylim(0,1)
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.title(str('Epochs: '+str(EPOCHS)+', Scalar: '+str(SCALAR)))
    plt.show()

    inputs = [ np.array([[0,0]]), np.array([[0,1]]), np.array([[1,0]]), np.array([[1,1]])]
    print "X\ty\ty_hat"
    for inp in inputs:
        print (inp[0][0],inp[0][1]),"\t",xor(inp[0][0],inp[0][1]),"\t",round(nn.forward(inp)[0][0],4)

X       y       y_hat
(0, 0)  0       0.0
(0, 1)  1       0.9997
(1, 0)  1       0.9997
(1, 1)  0       0.0005

[ [-0.81781753  0.71323677]
  [ 0.48803631 -0.71286155] ]

[ [ 2.04849235]
  [ 1.40170791] ]