#include<stdio.h>
#include <stdlib.h>
#include <math.h>
#include<time.h>

/*
    神经网络输入层有三个结点，隐含层有5个节点，隐含层的激活函数为tansig；输出层有1个结点，激活函数为logsig。
    利用此网络对药品的下一年1月份销售量进行预测。
    原始数值归一化处理结果：
    【1】输入值：
    0.5152  0.8173  1.0000
    0.8173  1.0000  0.7308
    1.0000  0.7308  0.1390
    0.7308  0.1390  0.1087
    0.1390  0.1087  0.3200
    0.1087  0.3520  0.0000
    【2】期望输出值
    0.7308  0.1390  0.1087  0.3520  -0.0027 0.3761
*/

#define η 0.1  //学习常数
#define N 12    //数组元素个数
#define P_ROW 6 //行数（总的训练数据组数）
#define P_COL 3 //列数（每一组训练数据中的数据个数）
#define OUT_NUM 6//输出值个数
#define ih_ROW 5    //第1层权值矩阵行数
#define ih_COL 3    //第1层权值矩阵列数
#define ho_Col 5    //第2层权值矩阵列数
#define hiddenNum 5 //隐含层的值个数

double findMaxVal(double X[N], int size);//获取最大值
double findMinVal(double X[N], int size);//获取最小值
void normalizationData(double pData[P_ROW][P_COL], int row, int col);//归一化处理
void initWeightMatrix(double WeightVal_ih[ih_ROW][ih_COL], double WeightVal_ho[ho_Col]);//初始化权值矩阵:生成0-1之间得权值
void forwardProcessing(double inputVal[3], double hiddenVal[hiddenNum], double* outputVal);//正向处理数据
void adjustWeightMatrix(double ExpVal, double* outputVal, double WeightVal_ho[ho_Col], double hiddenVal[hiddenNum], double WeightVal_ih[ih_ROW][ih_COL], double inputVal[3]);//4、误差逆向传播-调整权值矩阵
double tansig(double Val);//隐含层激励函数
double logsig(double Val);//输出层激励函数
double reverseTrans(double normalVal);//从归一化指数逆变换为原数值


//初始数据数组：12个月份的对应值
double X[N] = { 2056, 2395, 2600, 2298, 1634, 1600,
                1873, 1478, 1900, 1500, 2046, 1556 };
//训练数据:6组
double pData[P_ROW][P_COL] = { { 2056, 2395, 2600 },
                                { 2395, 2600, 2298 },
                                { 2600, 2298, 1634 },
                                { 2298, 1634, 1600 },
                                { 1634, 1600, 1837 },
                                { 1600, 1873, 1478 } };
//输出的期望值:6个
double OutData[OUT_NUM] = { 2298, 1634, 1600, 1873, 1475, 1900 };
//第1层权值数组：5*3
double WeightVal_ih[ih_ROW][ih_COL];
//第2层权值数组：1*5
double WeightVal_ho[ho_Col];
//隐含层的值:1*5
double hiddenVal[hiddenNum];
//输出层的值
double outputVal=0;


int main(int args, char* argv[])
{
    printf("人工神经网络预测模型\n");
    //【1】数据预处理
    srand((unsigned int)time(NULL));
    normalizationData(pData, P_ROW, P_COL);//1、归一化处理数据
    initWeightMatrix(WeightVal_ih, WeightVal_ho);//2、初始化权值矩阵

    //【2】、开始训练数据
    double *inputVal =NULL;//数据游标，控制训练数据组下标不断后移
    double ExpVal = 0;//记录期望输出值
    int count = 1;//计数器
    while (count<=50000)//这里只是设定了对训练次数的要求，对于误差限定，可使用一个数组记录每一轮得到的误差值进行限定
    {
        printf("******************第%d轮运算*******************\n",count);
        for (int i = 0; i < P_ROW; i++)
        {
            inputVal = pData[i];//用一级指针代替一维数组作为参数传递
            ExpVal = OutData[i];//记录当前次处理结果的期望输出值
            forwardProcessing(inputVal, hiddenVal, &outputVal);//3、正向处理数据
            adjustWeightMatrix(ExpVal, &outputVal, WeightVal_ho, hiddenVal, WeightVal_ih, inputVal);//4、逆向传播误差，修改权值
            printf("输出值=%.4f\t误差值=%.4f\n", outputVal, (outputVal - ExpVal));
        }
        count++;
        printf("*****************************************************\n");
    }

    //【3】检验训练成果
    printf("*****************检验训练成果*********************\n");
    double Data[P_ROW][P_COL] = { { 2056, 2395, 2600 },
                                { 2395, 2600, 2298 },
                                { 2600, 2298, 1634 },
                                { 2298, 1634, 1600 },
                                { 1634, 1600, 1837 },
                                { 1600, 1873, 1478 } };
    double realData[OUT_NUM] = { 2298, 1634, 1600, 1873, 1475, 1900 };
    normalizationData(Data, P_ROW, P_COL);
    for (int i = 0; i < P_ROW; i++)
    {
        inputVal = Data[i];//用一级指针代替一维数组作为参数传递
        forwardProcessing(inputVal, hiddenVal, &outputVal);//3、正向处理数据
        printf("预测值=%.4f\t实际值=%.4f\n", reverseTrans(outputVal), realData[i]);
    }
    //【4】利用训练结果预测数据
    printf("\n*****************利用训练结果预测数据*********************\n");
    //1500, 2046, 1556,归一化处理后对应数值为：[最大值-2600，最小值1478]
    double predictData[1][3] = { { 1500, 2046, 1556 } };
    //归一化处理
    normalizationData(predictData, 1, 3);//归一化处理
    //得到隐含层的值
    forwardProcessing(predictData, hiddenVal, &outputVal);
    printf("最终预测得到归一化值为:%.4f\n对应下一年1月份销售额为:%.4f,", outputVal, reverseTrans((outputVal)));
    system("pause");
    return 0;
}

//从归一化指数逆变换为原数值
double reverseTrans(double normalVal)
{
    double maxVal = findMaxVal(X,N);
    double minVal = findMinVal(X,N);
    return normalVal*(maxVal - minVal) + minVal;
}

//1、归一化处理
void normalizationData(double pData[P_ROW][P_COL], int row, int col)
{
    //printf("归一化处理结果\n");
    int i, j;
    double maxVal = findMaxVal(X, N);//寻找最大值
    double minVal = findMinVal(X, N);//寻找最小值
    //printf("maxVal=%.2f\nminVal=%.2f\n", maxVal,minVal);
    //【1】归一化处理输入数据
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            pData[i][j] = (pData[i][j] - minVal) / (maxVal - minVal);
            //printf("%.4f\t", pData[i][j]);
        }//end for-内
        //printf("\n");
    }//end for-外
    //printf("\n");
    //【2】归一化处理输出数据：OutData[OUT_NUM]
    for (i = 0; i < OUT_NUM; i++)
    {
        OutData[i] = (OutData[i] - minVal) / (maxVal - minVal);
        //printf("%.4f\t", OutData[i]);
    }
}

//2、初始化权值矩阵:生成0-1之间得权值
void initWeightMatrix(double WeightVal_ih[ih_ROW][ih_COL], double WeightVal_ho[ho_Col])
{
    //printf("初始化权重矩阵\n");
    int i, j;
    //初始化第一层权值矩阵：5*3
    for (i = 0; i < ih_ROW; i++)
    {
        for (j = 0; j < ih_COL; j++)
        {
            WeightVal_ih[i][j] = rand() / (RAND_MAX + 1.0);
            //printf("%.4f\t", WeightVal_ih[i][j]);
        }
    //  printf("\n");
    }
    //初始化第二层权值矩阵：1*5
    for (i = 0; i < ho_Col; i++)
    {
        WeightVal_ho[i] = rand() / (RAND_MAX + 1.0);
        //printf("w[%d]=%.4f\t",i,WeightVal_ho[i]);
    }
}

//3、正向处理数据:输入值->隐含层
void forwardProcessing(double inputVal[3], double hiddenVal[hiddenNum], double* outputVal)
{
    //printf("正向处理\n");
    int i, j,k;
    //【1】计算得到5个隐含层的值
    double sum_ih = 0.0;
    for (i = 0; i < hiddenNum;i++)//控制得到隐含层值必要的计算层数：5
    {
        for (j = 0; j < 3;j++)//求和：权重*输入值
        {
            sum_ih += inputVal[j] * WeightVal_ih[i][j];
        }
        hiddenVal[i] = tansig(sum_ih);//第i个输出的隐含层
        //printf("%.4f\t",hiddenVal[i]);
        sum_ih = 0;//将刻度值重置为0
    }
    //printf("\n");
    //【2】计算得到1个输出层的值-单个外层循环，可省略
    double sum_ho = 0.0;
    for (j = 0; j < hiddenNum;j++)
    {
        sum_ho += hiddenVal[j] * WeightVal_ho[j];
    }
    *outputVal = logsig(sum_ho);//输出层的值
    //printf("%.4f\n",*outputVal);
}

//4、误差逆向传播-调整权值矩阵
void adjustWeightMatrix(double ExpVal, double* outputVal, double WeightVal_ho[ho_Col], double hiddenVal[hiddenNum], double WeightVal_ih[ih_ROW][ih_COL], double inputVal[3])
{
    //printf("逆向处理\n");
    int i, j;
    double dt_oh;//权值的改正参数
    double dW_oh;//权值的改正值
    //【1】调整第2层权值
    double RealVal = *outputVal;
    dt_oh = RealVal*(1 - RealVal)*(ExpVal - RealVal);//权值改正值的参数
    for (i = 0; i < hiddenNum;i++)
    {
        dW_oh = η*dt_oh*hiddenVal[i];//权值改正值
        //printf("%.8f\t",dW_oh);
        WeightVal_ho[i] += dW_oh;//改正后权值

    }
    //printf("\n");
    //【2】调整第1层权值：5*3*个
    double dt_hi;
    double dw_hi;
    double realVal;
    for (i = 0; i < hiddenNum;i++)//5个改正值参数
    {
        realVal = hiddenVal[i];
        dt_hi = realVal*(1 - realVal)*dt_oh*WeightVal_ho[i];
        for (j = 0; j < 3;j++)
        {
            dw_hi = η*dt_hi*inputVal[j];//权值改正值
            WeightVal_ih[i][j] += dw_hi;//改正后权值
        }
    }
}

//获取最大值
double findMaxVal(double X[N], int size)
{
    int i, maxVal = X[0];
    for (i = 1; i < size; i++)
    {
        if (X[i]>maxVal)
        {
            maxVal = X[i];
        }
    }
    return maxVal;
}

//获取最小值
double findMinVal(double X[N], int size)
{
    int i, minVal = X[0];
    for (i = 1; i < size; i++)
    {
        if (X[i] < minVal)
        {
            minVal = X[i];
        }
    }
    return minVal;
}

//隐含层激励函数
double tansig(double Val)
{
    /*
    double exp(double x)
    返回 e 的 x 次幂的值*/
    return  ((2 / (1 + exp(-2 * Val))) - 1);
}

//输出层激励函数
double logsig(double Val)
{
    return 1 / (1 + (exp(-1 * Val)));
}