A super simple neural network code with 5 coordinates for one layer node training

ILearnDeepLearning.py/Numpy deep neural network.ipynb at master · SkalskiP/ILearnDeepLearning.py · GitHub
 I extract a layer of node training according to the code in this article 5 Super simple neural network code of coordinates 
 The second quadrant point is 0 class , The first quadrant is 1 class 

import numpy as np


def sigmoid(x):
    return 1.0/(1+np.exp(-x))

def sigmoid_backward( Z):
    sig = sigmoid(Z)
    return sig * (1 - sig)

# The negative number of the first coordinate is 0 class , The first coordinate with positive number is 1 class 
X = np.array( [  [3.,5.], [4.,2.], [1.,1.], [-5.,4.], [-4.,2.]  ] )
Y = np.array( [ 1,1,1,0,0 ] )
if __name__ == '__main__':
    n_samples = X.shape[0]
    print( X.T.shape )
    W = np.array([[1.0, 1.0]])
    b = np.array([[1.0]])

    for i in range(100):
        # Forward propagation 
        Z = np.dot( W, X.T) + b
        A = sigmoid(Z)
        Y_hat = A
        # Back propagation 
        dA = 2*( Y_hat - Y )
        dZ = dA * sigmoid_backward( Z )
        dW = np.dot(dZ, X) / n_samples
        db = np.sum(dZ, axis=1, keepdims=True) / n_samples

        #0.01 It's the learning rate , I think it's the rate of convergence 
        W -= 0.01 * dW
        b -= 0.01 * db

        #print( dA )

        continue

    #    Test data     The first is 1 class ,  The second is 0 class    The first coordinate number is too close 0, The easier it is to make mistakes 
    X = np.array([ [30., 5.], # The first is 1 class 
                   [-40, 2.] ]) # The second is 0 class 
    Z = np.dot(W, X.T) + b
    A = sigmoid(Z)
    Y_hat = A
    print(Y_hat)

 There are differences between programming expression and mathematical formula expression , It is difficult to get the correct prediction results if programming purely according to mathematical formulas 
1、 if Z'(A)dA=dZ(A); When programming gradient descent ,dA Expressed as Z'(A),dZ(A) As a 1, Don't subtract the marked value from the predicted value ：(Z^-Z)
 namely dA=Z'(A)*1, Finally, multiply it by the learning rate .
 also dA Do not express as dZ(A)/Z'(A), Do not express as (Z^-Z)/Z'(A), Do not express as Z'(A)*(Z^-Z)
2、 if W*X+B=Z, be dW=dZ*X.T,X.T yes X The transpose matrix of .X It's usually n That's ok 1 Column .

Here is what I look like after correcting my code , Discovery use △ by 0.000001 A similar prediction can also be obtained by replacing the derivative function with the calculated slope value of ：

import numpy as np


def sigmoid(x):
    return 1.0/(1+np.exp(-x))

def sigmoid_backward( Z):
    sig = sigmoid(Z)
    return np.multiply( sig , (1 - sig) )

def square(x):
    return np.multiply( x, x )

def derivative( func , x, d=0.000001):
    return (func(x+d)-func(x)) / d

x= [ [[3.],[5.]], [[4.],[2.]], [[2.],[3.]], [[1.],[1.]], [[-1.],[5.]], [[-5.],[4.]], [[-4.],[2.]], [[-3.2],[2.5]]   ]
type= [ [[1.],[0.]], [[1.],[0.]], [[1.],[0.]], [[1.],[0.]],  [[0.],[1.]], [[0.],[1.]], [[0.],[1.]], [[0.],[1.]]  ]

x= [ [[3.],[5.]], [[-1.],[5.]] ]
type= [ [[1.],[0.]],   [[0.],[1.]]  ]

A=[ [1.,1.], [1.,1.]  ]
B=[ [1.],[1.] ]

if __name__ == '__main__':
    count = len(x)
    xList= x
    yList= type

    for i in range(10000):
        oList = []
        ypList = []
        for x in xList:
            x = np.matrix(x)
            o = np.matrix(A)*(x)+B
            oList.append( o )
            yp= sigmoid(o)

            ypList.append( yp )

        E = 0
        M = 0
        for  index ,yp in enumerate(ypList):
            k = np.multiply( derivative(square, yp - yList[index], 0.0001), #2*(yp - yList[index])  ,                  #derivative(square, yp - yList[index], 0.0001),
                             derivative( sigmoid, oList[index], 0.0001 ) ) #sigmoid_backward( oList[index] ) )
                            #derivative( sigmoid, oList[index], 0.0001 ))
            m = k #np.multiply(k, yList[index] - yp)
            M = M + m
            E = E + ( m*( np.matrix(xList[index]).T ) )

        E = E/count
        M = M/count

        A -= np.multiply( 0.1, E )
        B -= np.multiply( 0.1, M )
        #print( ypList )

    oList = []
    ypList = []
    for x in xList:
        x = np.matrix(x)
        o = A * x + B
        oList.append(o)
        yp = sigmoid(o)

        ypList.append(yp)

    print( ypList )