cneural-networkruntime-error

ANN in C "Run-Time Check Failure #2 - Stack around the variable 'outputLayer' was corrupted." Error after running


I wrote a neural network in C. There is a neuron model structure and input, hidden then output layer structures. This code was actually written in Python but I transformed it to C. After the debugging or running there is a error like that "Run-Time Check Failure #2 - Stack around the variable 'outputLayer' was corrupted." The predicton output is correct but in the end the error occurred. Here is the code below.

#include<stdio.h>
#include<math.h>
#define INPUT_SIZE 3 
#define HIDDEN_SIZE 8
#define OUTPUT_SIZE 1
#define LEARNING_RATE 0.09
#define EPOCHS 20000



struct Neuron {
    double weights[INPUT_SIZE];

    double bias;
};

double relu(double x) {
    return fmax(0, x);
}

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

double sigmoid_derivative(double x) {
    return x * (1 - x);
}

double calculateNeuronOutput(struct Neuron *neuron, double inputs[], int use_relu) {

    double sum = neuron->bias;
    for (int i = 0; i < INPUT_SIZE; i++) {
        sum += inputs[i] * neuron->weights[i];
    }
    
    if (use_relu){
        return relu(sum);
    }
    else {
        return sigmoid(sum);
    }

}
void backPropagation(struct Neuron inputLayer[], struct Neuron hiddenLayer[], 
                          struct Neuron outputLayer[], double inputVector[], double target) {

    double hiddenLayerOutput[HIDDEN_SIZE];
    for (int i = 0; i < HIDDEN_SIZE; i++) {
        hiddenLayerOutput[i] = calculateNeuronOutput(&hiddenLayer[i], inputVector, 1);
    }

    double output = calculateNeuronOutput(&outputLayer[0], hiddenLayerOutput, 0);

    double error = 0.5 * pow(target - output, 2);

    double output_error = target - output;
    double output_delta = output_error * sigmoid_derivative(output);

    double hiddenLayer_error[HIDDEN_SIZE];
    for (int i = 0; i < HIDDEN_SIZE; i++) {
        hiddenLayer_error[i] = output_delta * outputLayer[0].weights[i];
    }

    for (int i = 0; i < HIDDEN_SIZE; i++) {
        for (int j = 0; j < INPUT_SIZE; j++) {
            hiddenLayer[i].weights[j] += LEARNING_RATE * hiddenLayer_error[i] * inputVector[j];

        }
        hiddenLayer[i].bias += LEARNING_RATE * hiddenLayer_error[i];
    }

    for (int i = 0; i < OUTPUT_SIZE; i++) {
        for (int j = 0; j < HIDDEN_SIZE; j++) {
            outputLayer[i].weights[j] += LEARNING_RATE * output_delta * hiddenLayerOutput[j];
        }
        outputLayer[i].bias += LEARNING_RATE * output_delta;
    }
}


int main() {
        
    struct Neuron inputLayer[INPUT_SIZE] = {
        {{0.1, -0.2, 0.3}, 0.1},
        {{0.2, -0.1, -0.3}, 0.2},
        {{0.3, 0.4, -0.1}, 0.2},
    };

    struct Neuron hiddenLayer[HIDDEN_SIZE] = {
        {{0.1, 0.2, 0.3}, 0.1},
        {{0.2, 0.1, -0.3}, 0.2},
        {{0.3, 0.4, 0.1}, 0.3},
        {{0.2, 0.1, 0.4}, -0.4},
        {{0.5, 0.2, -0.3}, -0.1},
        {{0.1, 0.3, 0.2}, 0.4},
        {{0.3, -0.4, 0.1}, 0.2},
        {{0.4, 0.2, -0.1}, -0.3}

    };

    struct Neuron outputLayer[OUTPUT_SIZE] = {
        {{0.1, -0.2, 0.3}, 0.2}

    };
    
    double inputVector[4][INPUT_SIZE] = { { 0.0, 0.0, 1.0 },{0.0, 1.0, 0.0},{0.0, 1.0, 1.0},{1.0, 1.0, 1.0 } };
    double targetOutput[4] = { {0.0},{1.0},{1.0},{0.0} };

    for (int epoch = 0; epoch < EPOCHS; epoch++) {

        for(int i=0; i< 4; i++){
            
            backPropagation(inputLayer, hiddenLayer, outputLayer, inputVector[i], targetOutput[i]);
        }
            

        if (epoch % 1000 == 0) {
            double totalError = 0.0;
            for (int i = 0; i < 4; i++) {

                double hiddenLayerOutput[HIDDEN_SIZE];
                for (int j = 0; j < HIDDEN_SIZE; j++) {
                    hiddenLayerOutput[j] = calculateNeuronOutput(&hiddenLayer[j], inputVector[i], 1);
                }
                double output = calculateNeuronOutput(&outputLayer[0], hiddenLayerOutput, 0);

                double error = 0.5 * pow(targetOutput[i] - output, 2);
                totalError += error;

            }
            printf("Epoch: %d, Loss: %f\n", epoch, totalError);
        }
    }
    
    // Tahmin 

    double predictionInput[4][INPUT_SIZE] = { { 0.0, 0.0, 1.0 },{0.0, 0.0, 1.0},{0.0, 1.0, 1.0},{0.0, 1.0, 1.0 } };
    
    for (int i = 0; i < 4; ++i) {
        double hiddenLayerOutput[HIDDEN_SIZE];
        for (int j = 0; j < HIDDEN_SIZE; ++j) {
            hiddenLayerOutput[j] = calculateNeuronOutput(&hiddenLayer[j], predictionInput[i], 1);
        }

        double finalOutput = calculateNeuronOutput(&outputLayer[0],hiddenLayerOutput, 0);

        printf("Input: (%f, %f, %f), Exact Output: %f, Predicton: %f\n",
            predictionInput[i][0], predictionInput[i][1], predictionInput[i][2], targetOutput[i], finalOutput);
    }

    return 0;

}

I can get a output which is below but in the last line I got this error.

{Epoch: 0, Loss: 0.526654
Epoch: 1000, Loss: 0.003173
Epoch: 2000, Loss: 0.001147
Epoch: 3000, Loss: 0.000665
Epoch: 4000, Loss: 0.000458
Epoch: 5000, Loss: 0.000346
Epoch: 6000, Loss: 0.000275
Epoch: 7000, Loss: 0.000228
Epoch: 8000, Loss: 0.000194
Epoch: 9000, Loss: 0.000168
Epoch: 10000, Loss: 0.000148
Epoch: 11000, Loss: 0.000132
Epoch: 12000, Loss: 0.000119
Epoch: 13000, Loss: 0.000108
Epoch: 14000, Loss: 0.000099
Epoch: 15000, Loss: 0.000091
Epoch: 16000, Loss: 0.000085
Epoch: 17000, Loss: 0.000079
Epoch: 18000, Loss: 0.000074
Epoch: 19000, Loss: 0.000069
Input: (0.000000, 0.000000, 1.000000), Act Output: 0.000000, Prediction: 0.006382
Input: (0.000000, 1.000000, 0.000000), Act Output: 1.000000, Prediction: 0.999901
Input: (0.000000, 1.000000, 1.000000), Act Output: 1.000000, Prediction: 0.992201
Input: (1.000000, 1.000000, 1.000000), Act Output: 0.000000, Prediction: 0.005400 }

And this is the error: {Run-Time Check Failure #2 - Stack around the variable 'outputLayer' was corrupted.}


Solution

  • At least this, in backPropagation():

        double hiddenLayer_error[HIDDEN_SIZE];
        for (int i = 0; i < HIDDEN_SIZE; i++) {
            hiddenLayer_error[i] = output_delta * outputLayer[0].weights[i];
        }
    

    outputLayer[0].weights[] is an array of size 3.

    Your loop indexes that array from 0 to 7, which will cause undefined behaviour.

    You have the same problem in this code:

        for (int i = 0; i < OUTPUT_SIZE; i++) {
            for (int j = 0; j < HIDDEN_SIZE; j++) {
                outputLayer[i].weights[j] += LEARNING_RATE * output_delta * hiddenLayerOutput[j];
            }
            outputLayer[i].bias += LEARNING_RATE * output_delta;
        }