Sửa lại mã sau và cho biết lệnh biên dịch: #include <stdio.h>

include <stdlib.h>

include <math.h>

define INPUT_SIZE 2

define HIDDEN_SIZE 2

define OUTPUT_SIZE 1

double sigmoid(double x) { return 1.0 / (1.0 + exp(-x)); }

int main() { double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}}; double target[4][1] = {{0}, {1}, {1}, {0}}; double hidden[HIDDEN_SIZE]; double output[OUTPUT_SIZE]; double weight_ih[INPUT_SIZE][HIDDEN_SIZE]; double weight_ho[HIDDEN_SIZE][OUTPUT_SIZE]; double bias_h[HIDDEN_SIZE]; double bias_o[OUTPUT_SIZE]; double learning_rate = 0.1; int epoch = 10000;

// Initialize weights and biases
for (int i = 0; i < INPUT_SIZE; i++) {
    for (int j = 0; j < HIDDEN_SIZE; j++) {
        weight_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++) {
        weight_ho[i][j] = ((double) rand() / RAND_MAX) * 2.0 - 1.0;
    }
    bias_h[i] = ((double) rand() / RAND_MAX) * 2.0 - 1.0;
}
bias_o[0] = ((double) rand() / RAND_MAX) * 2.0 - 1.0;

// Train the network
for (int e = 0; e < epoch; e++) {
    double error = 0.0;
    for (int i = 0; i < 4; i++) {
        // Forward pass
        for (int j = 0; j < HIDDEN_SIZE; j++) {
            hidden[j] = bias_h[j];
            for (int k = 0; k < INPUT_SIZE; k++) {
                hidden[j] += input[i][k] * weight_ih[k][j];
            }
            hidden[j] = sigmoid(hidden[j]);
        }
        for (int j = 0; j < OUTPUT_SIZE; j++) {
            output[j] = bias_o[j];
            for (int k = 0; k < HIDDEN_SIZE; k++) {
                output[j] += hidden[k] * weight_h[k][j];
            }
            output[j] = sigmoid(output[j]);
        }

        // Backward pass
        double delta_o = (target[i][0] - output[0]) * output[0] * (1.0 - output[0]);
        error += 0.5 * (target[i][0] - output[0]) * (target[i][0] - output[0]);
        for (int j = 0; j < HIDDEN_SIZE; j++) {
            double delta_h = delta_o * weight_h[j][0] * hidden[j] * (1.0 - hidden[j]);
            for (int k = 0; k < INPUT_SIZE; k++) {
                weight_ih[k][j] += learning_rate * delta_h * input[i][k];
            }
            weight_ho[j][0] += learning_rate * delta_o * hidden[j];
            bias_h[j] += learning_rate * delta_h;
        }
        bias_o[0] += learning_rate * delta_o;
    }
    printf("Epoch %d: error = %f\n", e, error);
}

// Test the network
for (int i = 0; i < 4; i++) {
    for (int j = 0; j < HIDDEN_SIZE; j++) {
        hidden[j] = bias_h[j];
        for (int k = 0; k < INPUT_SIZE; k++) {
            hidden[j] += input[i][k] * weight_ih[k][j];
        }
        hidden[j] = sigmoid(hidden[j]);
    }
    for (int j = 0; j < OUTPUT_SIZE; j++) {
        output[j] = bias_o[j];
        for (int k = 0; k < HIDDEN_SIZE; k++) {
            output[j] += hidden[k] * weight_h[k][j];
        }
        output[j] = sigmoid(output[j]);
    }
    printf("Input: %d %d, Output: %f\n", (int) input[i][0], (int) input[i][1], output[0]);
}

return 0;

}