XOR neural network with python

Question

I developed a neural.network representing an XOR gate using the sigmoid function as the activation function and the loss function as the objective function. the question is to let the training continues while the training error is above 0.3

import numpy as np 
np.random.seed(0)

def sigmoid (x):
    # compute and return the sigmoid activation value for a
    # given input value
    return 1.0/(1 + np.exp(-x))

def sigmoid_derivative(x):
    # compute the derivative of the sigmoid function
    return x * (1 - x)

def loss(residual):
    # compute the loss function
    return residual * residual

def loss_derivative(residual):
    # compute the derivative of the loss function
    return 2 * residual

    

#Define the inputs and stucture of neural network
# XOR Inputs
inputs = np.array([[0,0],[0,1],[1,0],[1,1]])
# XOR Output
expected_output = np.array([[0],[1],[1],[0]])

# Learning rate
lr = 0.1
# Number of neurons
n_x = 2
n_h = 2
n_y = 1

#Random weights initialization
hidden_weights = np.random.rand(n_x,n_h)
output_weights = np.random.rand(n_h,n_y)


print("Initial hidden weights: ",end='')
print(*hidden_weights)
print("Initial output weights: ",end='')
print(*output_weights)



#Training algorithm
# loop over each individual data point and train
# the network on it
count = 0
while(True):
    # FEEDFORWARD:
    # feedforward the activation at the current layer by
    # taking the dot product between the activation and the weight matrix 
    hidden_layer_activation = np.dot(inputs,hidden_weights)
    hidden_layer_output = sigmoid(hidden_layer_activation)

    output_layer_activation = np.dot(hidden_layer_output,output_weights)
    predicted_output = loss(output_layer_activation)

    # BACKPROPAGATION
    #the first phase of backpropagation is to compute the
    # difference between the *prediction* and the true target value y-ŷ
    error = predicted_output - expected_output 
    if (error < 0.3).any():   break
    d_predicted_output = error * loss_derivative(predicted_output)
    
    error_hidden_layer = d_predicted_output.dot(output_weights.T)
    d_hidden_layer = error_hidden_layer * sigmoid_derivative(hidden_layer_output)

    #Updating Weights 
    output_weights += hidden_layer_output.T.dot(d_predicted_output) * lr
    hidden_weights += inputs.T.dot(d_hidden_layer) * lr
    
print("Final hidden weights: ",end='')
print(*hidden_weights)

print("Final output weights: ",end='')
print(*output_weights)

print("\nOutput from neural network after learning: ",end='')
print(*predicted_output)

but when I write a condition like

if (error < 0.3).any():   break

the program does only one iteration and then stop

can anyone tell me what the problem is with my code?

Answer 1

You need to use the absolute error, as if it underpredicts, the error is negative:

np.abs(error < 0.3).any()

However, you also probably want the mean error:

np.mean(np.abs(error)) < 0.3