/* A ⊕ B = A`B + AB` The truth table for this boolean expression: A B C ( Actual Output ) 0 0 0 0 1 1 1 0 1 1 1 0 This code implements a neural network with ReLU activation for the hidden layer, sigmoid activation for the output layer, and backpropagation for training. It trains the neural network to learn the XOR function and tests its performance on the same function with maximum accuracy, here is the approaches below I mentioned to approach the highest accuracy on its outputs. First dicuss our Macro Definitions: #define INPUT_SIZE 2: Defines the size of the input layer as 2. #define HIDDEN_SIZE 4: Defines the size of the hidden layer as 4. #define OUTPUT_SIZE 1: Defines the size of the output layer as 1. #define LEARNING_RATE 0.5: Defines the learning rate for gradient descent. #define EPOCHS 5000: Defines the number of training epochs. Secondly we have Activation Functions: relu(double x): Implements the ReLU (Rectified Linear Unit) activation function. relu_derivative(double x): Computes the derivative of the ReLU function. Here is our Neural Network Structure: NeuralNetwork struct: Defines the structure of the neural network, including input, hidden, and output layers, as well as weights between layers. The Initialization Function: init(NeuralNetwork *nn): Initializes the neural network with random weights within the range of -1 to 1. Make it smart, Forward Pass Function: - forward(NeuralNetwork *nn): Computes the forward pass of the neural network. - Uses ReLU activation for the hidden layer and sigmoid activation for the output layer. - Computes the weighted sum of inputs for each neuron in the hidden layer and applies the ReLU activation function. - Computes the weighted sum of hidden layer outputs for the output neuron and applies the sigmoid activation function. and, Backpropagation Function: - backward(NeuralNetwork *nn, double target): Performs backpropagation to update the weights of the neural network. - Computes the error between the target and the output, and then updates the weights between the hidden and output layers. - Propagates the error back to the hidden layer and updates the weights between the input and hidden layers. Finally, Main Function: - Creates and initializes the neural network. Defines the training data (XOR function). - Trains the neural network using a loop over the specified number of epochs. - For each epoch, iterates over the training data, performs forward pass, and backpropagation. - Tests the trained neural network on the XOR function by passing inputs through the network and printing the output. */ #include #include #include #define INPUT_SIZE 2 #define HIDDEN_SIZE 4 // Increased hidden layer size for more capacity #define OUTPUT_SIZE 1 #define LEARNING_RATE 0.5 // Increased learning rate for faster convergence #define EPOCHS 5000 // Reduced number of epochs for faster training // ReLU activation function double relu(double x) { return fmax(0, x); } // Derivative of the ReLU function double relu_derivative(double x) { return x > 0 ? 1 : 0; } // Neural network structure typedef struct { double input[INPUT_SIZE]; double hidden[HIDDEN_SIZE]; double output[OUTPUT_SIZE]; double weights_ih[INPUT_SIZE][HIDDEN_SIZE]; double weights_ho[HIDDEN_SIZE][OUTPUT_SIZE]; } NeuralNetwork; // Initialize neural network with random weights void init(NeuralNetwork *nn) { for (int i = 0; i < INPUT_SIZE; i++) { for (int j = 0; j < HIDDEN_SIZE; j++) { nn->weights_ih[i][j] = (double)rand() / RAND_MAX * 2.0 - 1.0; } } for (int i = 0; i < HIDDEN_SIZE; i++) { for (int j = 0; j < OUTPUT_SIZE; j++) { nn->weights_ho[i][j] = (double)rand() / RAND_MAX * 2.0 - 1.0; } } } // Forward pass void forward(NeuralNetwork *nn) { // Compute hidden layer values with ReLU activation for (int i = 0; i < HIDDEN_SIZE; i++) { double sum = 0; for (int j = 0; j < INPUT_SIZE; j++) { sum += nn->input[j] * nn->weights_ih[j][i]; } nn->hidden[i] = relu(sum); } // Compute output layer values with sigmoid activation double sum = 0; for (int i = 0; i < HIDDEN_SIZE; i++) { sum += nn->hidden[i] * nn->weights_ho[i][0]; } nn->output[0] = 1.0 / (1.0 + exp(-sum)); // Sigmoid activation } // Backpropagation void backward(NeuralNetwork *nn, double target) { double output_error = (target - nn->output[0]) * nn->output[0] * (1.0 - nn->output[0]); // Update weights from hidden to output layer for (int i = 0; i < HIDDEN_SIZE; i++) { nn->weights_ho[i][0] += LEARNING_RATE * output_error * nn->hidden[i]; } // Update weights from input to hidden layer for (int i = 0; i < INPUT_SIZE; i++) { for (int j = 0; j < HIDDEN_SIZE; j++) { double hidden_error = output_error * nn->weights_ho[j][0] * relu_derivative(nn->hidden[j]); nn->weights_ih[i][j] += LEARNING_RATE * hidden_error * nn->input[i]; } } } int main() { // Create neural network NeuralNetwork nn; // Initialize neural network init(&nn); // Training data (XOR function) double inputs[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; double targets[4] = {0, 1, 1, 0}; // Train the neural network for (int epoch = 0; epoch < EPOCHS; epoch++) { for (int i = 0; i < 4; i++) { // Set input for (int j = 0; j < INPUT_SIZE; j++) { nn.input[j] = inputs[i][j]; } // Forward pass forward(&nn); // Backpropagation backward(&nn, targets[i]); } } // Test the neural network printf("Testing neural network:\n"); for (int i = 0; i < 4; i++) { // Set input for (int j = 0; j < INPUT_SIZE; j++) { nn.input[j] = inputs[i][j]; } // Forward pass forward(&nn); printf("Input: %d %d, Output: %.2f\n", (int)inputs[i][0], (int)inputs[i][1], nn.output[0]); } return 0; }

A neural network for XOR ML