Subversion Repositories tanhapprox

#include <stdlib.h>

#include <stdio.h>

#include <math.h>

#include "ann.h"

#include "Data.h"

// include definitions for performance counter and custom instruction

#include "altera_avalon_performance_counter.h"

#include "system.h"

// debug options

#define PRINT_RESULTS    1

#define ACCELERATED_TANH 0

#define ACCELERATED_FLOATING_POINT 1

#if ACCELERATED_FLOATING_POINT == 0

#pragma no_custom_fadds

#pragma no_custom_fsubs

#pragma no_custom_fmuls

#pragma no_custom_fdivs

#endif // ACCELERATED_FLOATING_POINT == 0

#if ACCELERATED_TANH != 0

#define ALT_F_LOGSIG_APPROX_INST(A) __builtin_custom_fnf(ALT_CI_LOGSIG_APPROX_INST_N,(A))

#endif // ACCELERATED_TANH != 0

float aOutput[DATA_LENGTH][DATA_WIDTH];

void PrintArray(float *aIn, int nLength)

{

        int nIndex;

    printf("\n");

        for (nIndex = 0; nIndex < nLength; nIndex++)

        {

                printf("%f ", aIn[nIndex]);

        }

        printf("\n");

}

int main()

{

        int nIndexCol, nIndexRow;

    float nMeanSquaredError = 0;

    float nCurrentError = 0;

        float aInputWeightsMultipliedByInput[DATA_WIDTH];

        float aIntermediate1[DATA_WIDTH];

        float aHiddenWeightsMultipliedByInt1[DATA_WIDTH];

        float aIntermediate2[DATA_WIDTH];

        float aOutputWeightsMultipliedByInt2[DATA_WIDTH];

    printf("Start: Tansig acceleration [%d], floating point unit [%d]\n", ACCELERATED_TANH, ACCELERATED_FLOATING_POINT );

    Normalize(aInput, DATA_LENGTH);

    ArrayFill(aOutput, DATA_LENGTH, 0);

    // start measuring time

    PERF_RESET (PERFORMANCE_COUNTER_0_BASE);            //Reset Performance Counters to 0

    PERF_START_MEASURING (PERFORMANCE_COUNTER_0_BASE);  //Start the Counter

    PERF_BEGIN (PERFORMANCE_COUNTER_0_BASE,2);          //Start the overhead counter

    PERF_BEGIN (PERFORMANCE_COUNTER_0_BASE,1);          //Start the Matrix Multiplication Counter

    PERF_END (PERFORMANCE_COUNTER_0_BASE,2);            //Stop the overhead counter

        for (nIndexCol = 0; nIndexCol < DATA_LENGTH; nIndexCol++)

        {

                MatrixMultiplication(aInputWeights, aInput[nIndexCol], aInputWeightsMultipliedByInput, false);

                MatrixAddition(aInputWeightsMultipliedByInput, aInputBias, aIntermediate1);

                ArrayTanh(aIntermediate1);

                MatrixMultiplication(aHiddenWeights, aIntermediate1, aHiddenWeightsMultipliedByInt1, false);

                MatrixAddition(aHiddenWeightsMultipliedByInt1, aHiddenBias, aIntermediate2);

                ArrayTanh(aIntermediate2);

                MatrixMultiplication(aOutputWeights, aIntermediate2, aOutputWeightsMultipliedByInt2, false);

                MatrixAddition(aOutputWeightsMultipliedByInt2, aOutputBias, aOutput[nIndexCol]);

        }

    PERF_END (PERFORMANCE_COUNTER_0_BASE,1);            //Stop the Matrix Multiplication Counter

    PERF_STOP_MEASURING (PERFORMANCE_COUNTER_0_BASE);   //Stop all counters  

    perf_print_formatted_report((void *)PERFORMANCE_COUNTER_0_BASE, ALT_CPU_FREQ, 2,

    "ANN Calcs","PC overhead");

        Unnormalize(aOutput, DATA_LENGTH);

#if PRINT_RESULTS != 0

        // Print results

        printf("Results\n");

        for (nIndexCol = 0; nIndexCol < DATA_LENGTH; nIndexCol++)

        {

                // print only the first 3 columns of result matrix (as result is a Nx3 matrix)

        printf("%f %f %f\n", aOutput[nIndexCol][0], aOutput[nIndexCol][1], aOutput[nIndexCol][2] );

        }

#endif // PRINT_RESULTS != 0

        for (nIndexCol = 0; nIndexCol < DATA_LENGTH; nIndexCol++)

        {

                for (nIndexRow = 0; nIndexRow < (DATA_WIDTH - 1); nIndexRow++)

                {

                        nCurrentError           = aOutput[nIndexCol][nIndexRow] - aExpectedResults[nIndexCol][nIndexRow];

                        nMeanSquaredError       += nCurrentError * nCurrentError;

                }

        }

        nMeanSquaredError = nMeanSquaredError / (DATA_LENGTH * (DATA_WIDTH - 1));

        printf("Mean Squared Error: %f", nMeanSquaredError);

        system("PAUSE");

}

void ArrayFill(float aInput[DATA_LENGTH][DATA_WIDTH], int nCountCol, float nValueToFill)

{

        int nIndexCol, nIndexRow;

    for (nIndexCol = 0; nIndexCol < nCountCol; nIndexCol++)

        {

                for (nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

                {

                        aInput[nIndexCol][nIndexRow] = nValueToFill;

                }

        }

}

void ArrayTanh(float aInput[DATA_WIDTH])

{

        int nIndexRow;

    for (nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

        {

        // choose between accelerated and non-accelerated tangent sigmoid

#if ACCELERATED_TANH == 0

        // non-accelerated (calculate with math.h)

                aInput[nIndexRow] = tanhf(aInput[nIndexRow]);

#else

        // accelerated (estimate with dedicated look-up table)

        aInput[nIndexRow] = ALT_F_LOGSIG_APPROX_INST(aInput[nIndexRow]);

#endif

        }

}

// Multiplies a 4x4 matrix by a 4x1

void MatrixMultiplication(float aMatrix1[DATA_WIDTH][DATA_WIDTH], float aMatrix2[DATA_WIDTH], float aOutput[DATA_WIDTH], char bPrintResults)

{

        int nIndexRow, nIndexCol;

    if (bPrintResults == true) printf("beginning matrix multiplication\n");

        // Init Output to 0's

        for (nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

        {

                aOutput[nIndexRow] = 0;

        }

        for (nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

        {

                for (nIndexCol = 0; nIndexCol < DATA_WIDTH; nIndexCol++)

                {

                        if (bPrintResults == true) printf("%f * %f\n",aMatrix1[nIndexRow][nIndexCol],aMatrix2[nIndexCol]);

                        aOutput[nIndexRow] += aMatrix1[nIndexRow][nIndexCol] * aMatrix2[nIndexCol];

                }

        }

}

// Adds two 4x1 matrices

void MatrixAddition(float aMatrix1[DATA_WIDTH], float aMatrix2[DATA_WIDTH], float aOutput[DATA_WIDTH])

{

        int nIndexRow;

    for (nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

        {

                aOutput[nIndexRow] = aMatrix1[nIndexRow] + aMatrix2[nIndexRow];

        }

}

// Normalizes matrix entries from -1 to 1

void Normalize(float aInput[DATA_LENGTH][DATA_WIDTH], int nCountCol)

{

        float aMin[DATA_WIDTH];

        float aMax[DATA_WIDTH];

        float nCurrentCell;

    int nIndexRow, nIndexCol;

        // First find min and max

        for ( nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++ )

        {

                aMin[nIndexRow] = 9999999; // HACK!!

                aMax[nIndexRow] = 0;

                for ( nIndexCol = 0; nIndexCol < nCountCol; nIndexCol++ )

                {

                        nCurrentCell = aInput[nIndexCol][nIndexRow];

                        if (nCurrentCell < aMin[nIndexRow]) aMin[nIndexRow] = nCurrentCell;

                        if (nCurrentCell > aMax[nIndexRow]) aMax[nIndexRow] = nCurrentCell;

                }

        }

        // Normalize

        for ( nIndexCol = 0; nIndexCol < nCountCol; nIndexCol++)

        {

                for ( nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

                {

                        nCurrentCell                                    = aInput[nIndexCol][nIndexRow];

                        aInput[nIndexCol][nIndexRow]    = (((nCurrentCell - aMin[nIndexRow]) / (aMax[nIndexRow] - aMin[nIndexRow])) * 2) - 1;

                }

        }

}

// "Un-normalizes matrix"

void Unnormalize(float aInput[][DATA_WIDTH], int nCountCol)

{

        int nIndexCol, nIndexRow;

    for ( nIndexCol = 0; nIndexCol < nCountCol; nIndexCol++)

        {

                for ( nIndexRow = 0; nIndexRow < DATA_WIDTH; nIndexRow++)

                {

                        aInput[nIndexCol][nIndexRow] = (aInput[nIndexCol][nIndexRow] + 1) / 2;

                }

        }

}