/******************************************************************************




 ******************************************************************************/




/******************************************************************************
                                    声明

 ******************************************************************************/

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <conio.h>

/******************************************************************************   
                                   宏定义                    
******************************************************************************/     

typedef int           BOOL;    //BOOL为INT型，它是一个三值逻辑 TRUE返回>0的整数，FALSE返回0，ERROR返回-1
typedef int           INT;
typedef double        REAL;

#define FALSE         0
#define TRUE          1
#define NOT           !
#define AND           &&
#define OR            ||

#define MIN_REAL      -HUGE_VAL
#define MAX_REAL      +HUGE_VAL
#define MIN(x,y)      ((x)<(y) ? (x) : (y))
#define MAX(x,y)      ((x)>(y) ? (x) : (y))

#define LO            0.1
#define HI            0.9
#define BIAS          1

#define sqr(x)        ((x)*(x))

/******************************************************************************   
                                结构变量声明                                    
******************************************************************************/     

typedef struct {                       
        INT          Units;          //层神经元数量    
        REAL*        Output;         //输出数 （即输出个矢量元素个数）    
        REAL*        Error;          //本层误差               
        REAL**        Weight;        //连接权    
        REAL**        WeightSave;    //保存训练调整后的连接权    
        REAL**        dWeight;       //调整量    
} LAYER;    //神经网络层结构    
  
typedef struct {                       
        LAYER**      Layer;          //神经网络各层指针    
        LAYER*        InputLayer;    //输入层    
        LAYER*        OutputLayer;   //输出层    
        REAL          Alpha;         //冲量参数    
        REAL          Eta;           //学习率           
        REAL          Error;         //总误差    
        REAL          Gain;          //gain of sigmoid function    
} NET;      //神经网络    
 


/******************************************************************************
                                  随机函数

 ******************************************************************************/

//设置伪随机数种子  

void InitializeRandoms()
{
  srand(4711);
}

//产生一个LOW - High之间的伪随机整数  

INT RandomEqualINT(INT Low, INT High)
{
  return rand() % (High-Low+1) + Low;
}      

//产生一个LOW - High之间的伪随机浮点数  

REAL RandomEqualREAL(REAL Low, REAL High)
{
  return ((REAL) rand() / RAND_MAX) * (High-Low) + Low;
}      


/******************************************************************************
                                  专用代码

 ******************************************************************************/


#define NUM_LAYERS    3     //网络层数    
INT                   N=30, Hidden=20, M=1;//输入层、隐藏层、输出层神经元个数
INT                   Units[NUM_LAYERS]={30,20,1};//用一维数组记录各层神经元个数     

#define FIRST_YEAR    1700
#define LAST_YEAR     1979
#define NUM_YEARS     280

#define TARGET_ERROR  0.0008   //目标误差
#define MAXEPOCHS     400      //最大迭代次数

#define TrainSetRate  0.75


REAL                  TrainError;
REAL                  TestError;

INT                   DataAmount;
INT                   DataSetCount;

INT                   TrainSetCount;
INT                   TestSetCount;
REAL**                TrainInput;
REAL**                TrainTarget;
REAL**                TestInput;
REAL**                TestTarget;
REAL*                 Max;
REAL*                 Min;

FILE*                 f;//声明文件指针    

BOOL ReadData()     /* Read the Data File*/
{
   FILE* Dataf;
   char  DataFileName[20];
   char  SaveFileName[30]={"BasicBPN_"};
   INT   p,q;
   REAL  ForCount;
   REAL  data;

   printf("Please input the datefile name (for example sunspot.txt) and press ENTER key \n: ");
   scanf("%s",DataFileName);

   if ((Dataf = fopen(DataFileName, "r")) == NULL) {
       printf("Cannot open %s\n", DataFileName);
       return FALSE;
   }

   DataAmount   =0;
   DataSetCount =0;
   while(NOT feof(Dataf))
   {
      if(DataAmount < 3){
         fscanf(Dataf, "%d", &N);
         fscanf(Dataf, "%d", &Hidden);
         fscanf(Dataf, "%d", &M);
         Units[0] = N; Units[1] = Hidden; Units[2] = M;
         DataAmount +=3;
      }else{
         fscanf(Dataf,"%lf",&ForCount);
         DataAmount++;
      }
     
   }

   if((DataAmount-3)%(N+M)!=0)
   {
       printf("Your datafile format is wrong,please check it.");
       return FALSE;
   }
   DataSetCount  = (DataAmount-3)/(N+M);
   TrainSetCount = (INT) floor(DataSetCount*TrainSetRate);
   TestSetCount  = DataSetCount-TrainSetCount;
   TrainInput    = (REAL**)  calloc(TrainSetCount+1, sizeof(REAL*));
   TrainTarget   = (REAL**)  calloc(TrainSetCount+1, sizeof(REAL*));
   TestInput     = (REAL**)  calloc(TestSetCount+1, sizeof(REAL*));
   TestTarget    = (REAL**)  calloc(TestSetCount+1, sizeof(REAL*)); 
   for (p=1;p<=TrainSetCount;p++){
       TrainInput[p]   = (REAL*)  calloc(N+1, sizeof(REAL));
       TrainTarget[p]  = (REAL*)  calloc(M+1, sizeof(REAL));  
   }
   for (p=1;p<=TestSetCount;p++){
       TestInput[p]    = (REAL*)  calloc(N+1, sizeof(REAL));
       TestTarget[p]   = (REAL*)  calloc(M+1, sizeof(REAL));  
   }

   rewind(Dataf);
   fscanf(Dataf, "%d", &N);
   fscanf(Dataf, "%d", &Hidden);
   fscanf(Dataf, "%d", &M);
   while(NOT feof(Dataf)){
       for (p=1; p<=TrainSetCount; p++){
           for (q=1; q<=N; q++){
               fscanf(Dataf,"%lf",&data);
               TrainInput[p][q]=data;
           }
           for (q=1; q<=M; q++){
               fscanf(Dataf,"%lf",&data);
               TrainTarget[p][q]=data;
           }
       }

       for (p=1; p<=TestSetCount; p++){
           for (q=1; q<=N; q++){
               fscanf(Dataf,"%lf",&data);
               TestInput[p][q]=data;
           }
           for (q=1; q<=M; q++){
               fscanf(Dataf,"%lf",&data);
               TestTarget[p][q]=data;
           }
       }          
   }

   fclose(Dataf);
   strcat(SaveFileName,DataFileName);
   f = fopen(SaveFileName, "w");
   return TRUE;
}


void NormalizeData()  /*normalize the date of sunspots*/
{
  INT  p,q;

  Max = (REAL*)  calloc((N+M+1), sizeof(REAL));
  Min = (REAL*)  calloc((N+M+1), sizeof(REAL));

  for (q=1; q<=(N+M); q++){
      Max[q] = MIN_REAL;
      Min[q] = MAX_REAL;
  }

  for (q=1; q<=N; q++){
      for (p=1; p<=TrainSetCount; p++){
          Max[q] = MAX(Max[q],TrainInput[p][q]);
          Min[q] = MIN(Min[q],TrainInput[p][q]);
      }
      for (p=1; p<=TestSetCount; p++){
          Max[q] = MAX(Max[q],TestInput[p][q]);
          Min[q] = MIN(Min[q],TestInput[p][q]);
      }
  }

 
  for (q=N+1; q<=N+M; q++){
      for (p=1; p<TrainSetCount; p++){
          Max[q] = MAX(Max[q],TrainTarget[p][q-N]);
          Min[q] = MIN(Min[q],TrainTarget[p][q-N]);
      }
      for (p=1; p<TestSetCount; p++){
          Max[q] = MAX(Max[q],TestTarget[p][q-N]);
          Min[q] = MIN(Min[q],TestTarget[p][q-N]);
      } 
  }

  for (q=1; q<=N; q++){
      for (p=1; p<=TrainSetCount; p++){
          TrainInput[p][q]    = (TrainInput[p][q] - Min[q])/(Max[q] - Min[q])*(HI - LO) + LO;  
      }
      for (p=1; p<=TestSetCount; p++){
          TestInput[p][q]     = ( TestInput[p][q] - Min[q])/(Max[q] - Min[q])*(HI - LO) + LO;
      }
  }

 
  for (q=N+1; q<=N+M; q++){
      for (p=1; p<=TrainSetCount; p++){
          TrainTarget[p][q-N] = (TrainTarget[p][q-N] - Min[q])/(Max[q] - Min[q])*(HI - LO) + LO;
      }
      for (p=1; p<=TestSetCount; p++){
          TestTarget[p][q-N]  = (TestTarget[p][q-N] - Min[q])/(Max[q] - Min[q])*(HI - LO)+ LO;
      } 
  }

}

void ReverseNormalizeData(REAL* Data, INT tag)
{
   INT q;

   if(tag==1){
     for (q=1; q<=M; q++){
       Data[q] = (Data[q] - LO)/(HI - LO) * (Max[q+N] - Min[q+N]) + Min[q+N];
     }
   }else{
     for (q=0; q<M; q++){
       Data[q] = (Data[q] - LO)/(HI - LO) * (Max[q+N+1] - Min[q+N+1]) + Min[q+N+1];
     }
   }
}


void InitializeApplication(NET* Net)
{

  Net->Alpha = 0.5;
  Net->Eta   = 0.05;
  Net->Gain  = 1;

  NormalizeData();
}

/****************************************************************************** 

 //关闭文件 
******************************************************************************/  

void FinalizeApplication(NET* Net)
{
  fclose(f);
}


/******************************************************************************
                   初始化：创建网络，为网络分配空间

 ******************************************************************************/


void GenerateNetwork(NET* Net)
{
  INT l,i;

  Net->Layer = (LAYER**) calloc(NUM_LAYERS, sizeof(LAYER*));
  
  for (l=0; l<NUM_LAYERS; l++) {
    Net->Layer[l] = (LAYER*) malloc(sizeof(LAYER));
     
    Net->Layer[l]->Units      = Units[l];
    Net->Layer[l]->Output     = (REAL*)  calloc(Units[l]+1, sizeof(REAL));
    Net->Layer[l]->Error      = (REAL*)  calloc(Units[l]+1, sizeof(REAL));
    Net->Layer[l]->Weight     = (REAL**) calloc(Units[l]+1, sizeof(REAL*));
    Net->Layer[l]->WeightSave = (REAL**) calloc(Units[l]+1, sizeof(REAL*));
    Net->Layer[l]->dWeight    = (REAL**) calloc(Units[l]+1, sizeof(REAL*));
    Net->Layer[l]->Output[0]  = BIAS;
     
    if (l != 0) {
      for (i=1; i<=Units[l]; i++) {
        Net->Layer[l]->Weight[i]     = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));
        Net->Layer[l]->WeightSave[i] = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));
        Net->Layer[l]->dWeight[i]    = (REAL*) calloc(Units[l-1]+1, sizeof(REAL));
      }
    }
  }
  Net->InputLayer  = Net->Layer[0];//为输入层分配指针 
  Net->OutputLayer = Net->Layer[NUM_LAYERS - 1];//为输出层分配指针 
  Net->Alpha       = 0.9;//冲量参数 
  Net->Eta         = 0.25;//学习率 
  Net->Gain        = 1;//始终不知道是啥……
}

/****************************************************************************** 
//随机生成联接权 
******************************************************************************/  

void RandomWeights(NET* Net)
{
  INT l,i,j;
  
  for (l=1; l<NUM_LAYERS; l++) {//每层 
    for (i=1; i<=Net->Layer[l]->Units; i++) {
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {
        Net->Layer[l]->Weight[i][j] = RandomEqualREAL(-0.5, 0.5);//随机值 
      }
    }
  }
}

/****************************************************************************** 

 获得输入层的输出 
******************************************************************************/  

void SetInput(NET* Net, REAL* Input)
{
  INT i;
  
  for (i=1; i<=Net->InputLayer->Units; i++) {
    Net->InputLayer->Output[i] = Input[i];
  }
}

/****************************************************************************** 

 获得输出层的输出 
******************************************************************************/  

void GetOutput(NET* Net, REAL* Output)
{
  INT i;
  
  for (i=1; i<=Net->OutputLayer->Units; i++) {
    Output[i-1] = Net->OutputLayer->Output[i];
  }
}


/******************************************************************************
          停止训练：保存连接权，防止丢失宝贵的联接权

 ******************************************************************************/


void SaveWeights(NET* Net)
{
  INT l,i,j;

  for (l=1; l<NUM_LAYERS; l++) {
    for (i=1; i<=Net->Layer[l]->Units; i++) {
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {
        Net->Layer[l]->WeightSave[i][j] = Net->Layer[l]->Weight[i][j];
      }
    }
  }
}

/****************************************************************************** 
          停止训练：恢复连接权，以便需要的时候可以重新调用，重组网络 
******************************************************************************/  

void RestoreWeights(NET* Net)
{
  INT l,i,j;

  for (l=1; l<NUM_LAYERS; l++) {
    for (i=1; i<=Net->Layer[l]->Units; i++) {
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {
        Net->Layer[l]->Weight[i][j] = Net->Layer[l]->WeightSave[i][j];
      }
    }
  }
}


/******************************************************************************
                                   传播信号

 ******************************************************************************/

/****************************************************************************** 
//计算当前层的网络输出，upper 为当前层，LOWER为前一层 
******************************************************************************/ 
void PropagateLayer(NET* Net, LAYER* Lower, LAYER* Upper)
{
  INT  i,j;
  REAL Sum;

  for (i=1; i<=Upper->Units; i++) {
    Sum = 0;
    for (j=0; j<=Lower->Units; j++) {
      Sum += Upper->Weight[i][j] * Lower->Output[j];//计算本层的净输入
    }
    Upper->Output[i] = 1 / (1 + exp(-Net->Gain * Sum));
  }
}

/****************************************************************************** 

 //计算整个网络各层的输出 
******************************************************************************/  

void PropagateNet(NET* Net)
{
  INT l;
  
  for (l=0; l<NUM_LAYERS-1; l++) {
    PropagateLayer(Net, Net->Layer[l], Net->Layer[l+1]);
  }
}


/******************************************************************************
                                   传回错误

 ******************************************************************************/

/****************************************************************************** 

 //计算输出层误差，* Target是导师信号 
******************************************************************************/  

void ComputeOutputError(NET* Net, REAL* Target)
{
  INT  i;
  REAL Out, Err;
  
  Net->Error = 0;
  for (i=1; i<=Net->OutputLayer->Units; i++) {
    Out = Net->OutputLayer->Output[i];//输出层的输出 
    Err = Target[i]-Out;//误差计算 
    Net->OutputLayer->Error[i] = Net->Gain * Out * (1-Out) * Err; //用delta规则计算误差，因为用了可导的s形函数 
    Net->Error += 0.5 * sqr(Err);//平方差公式 
  }
}

/****************************************************************************** 

 传回错误：误差反向传播 Upper 为前层，Lower为后层 ，层数值大的为前层 
******************************************************************************/  

void BackpropagateLayer(NET* Net, LAYER* Upper, LAYER* Lower)
{
  INT  i,j;//循环变量 
  REAL Out, Err;
  
  for (i=1; i<=Lower->Units; i++) {
    Out = Lower->Output[i];//后层的输出 
    Err = 0;//用来记录隐含层输出的误差的估计值 
    for (j=1; j<=Upper->Units; j++) {
      Err += Upper->Weight[j][i] * Upper->Error[j];//误差的反馈，通过已经处理的前层的delta值和联接权去估计，有理论基础 
    }
    Lower->Error[i] = Net->Gain * Out * (1-Out) * Err;//delta规则 
  }
}

/****************************************************************************** 

 传回错误：整个网络误差的后传 
******************************************************************************/  

void BackpropagateNet(NET* Net)
{
  INT l;//循环变量
  
  for (l=NUM_LAYERS-1; l>1; l--) {
    BackpropagateLayer(Net, Net->Layer[l], Net->Layer[l-1]);//对每层处理
  }
}

/****************************************************************************** 
传回错误：调整网络每一层的联接权 
******************************************************************************/  

void AdjustWeights(NET* Net)
{
  INT  l,i,j;//循环变量
  REAL Out, Err, dWeight;
    //记录后层的输出、当前层的输出误差、当前神经元联接权上次的调整量  

  for (l=1; l<NUM_LAYERS; l++) {
    for (i=1; i<=Net->Layer[l]->Units; i++) {
      for (j=0; j<=Net->Layer[l-1]->Units; j++) {
        Out = Net->Layer[l-1]->Output[j];//后层的输出 
        Err = Net->Layer[l]->Error[i];//当前层的输出误差 
        dWeight = Net->Layer[l]->dWeight[i][j];
         //将本神经元联接权上次的调整量取出，初始值为0，初始化网络时赋值的 
        Net->Layer[l]->Weight[i][j] += Net->Eta * Err * Out + Net->Alpha * dWeight;
         //Alpha为冲量参数，加快网络的收敛速度 
        Net->Layer[l]->dWeight[i][j] = Net->Eta * Err * Out;
         //记录本次神经元联接权的调整量 
      }
    }
  }
}


/******************************************************************************
                                    模拟网络

 ******************************************************************************/

/****************************************************************************** 

 训练网络 
//将每个样本投入网络运作，Input是转换后的输入模式，Target为导师信号，通过布尔型 
//的Training值控制是否训练
******************************************************************************/  

void SimulateNet(NET* Net, REAL* Input, REAL* Output, REAL* Target, BOOL Training)
{
  SetInput(Net, Input);//设置输入层，获得输入层的输出 
  PropagateNet(Net);//计算网络各层的输出 
  GetOutput(Net, Output);//获得输出层的输出 
  
  ComputeOutputError(Net, Target);//计算输出层误差 
  if (Training) {
    BackpropagateNet(Net);//误差反向传播 
    AdjustWeights(Net);//调整联接权 
  }
}


void TrainNet(NET* Net, INT Epochs)
{
  INT  p, n;
  REAL* Output;
  Output = (REAL*)  calloc(M, sizeof(REAL));

  for (n=0; n<Epochs*TrainSetCount; n++) {
    p = RandomEqualINT(1, TrainSetCount);
    SimulateNet(Net, TrainInput[p], Output, TrainTarget[p], TRUE);
  }
  free (Output);
}


void TestNet(NET* Net)
{
  INT  Count;
  REAL* Output;

  Output = (REAL*)  calloc(M, sizeof(REAL));
  TrainError = 0;
  for (Count=1; Count<=TrainSetCount; Count++) {
     SimulateNet(Net, TrainInput[Count], Output, TrainTarget[Count], FALSE);
    TrainError += Net->Error;
  }
  TestError = 0;
  for (Count=1; Count<=TestSetCount; Count++) {
     SimulateNet(Net, TestInput[Count], Output, TestTarget[Count], FALSE);
    TestError += Net->Error;
  }
  fprintf(f, "\nMSE is %0.8f on Training Set and %0.8f on Test Set", TrainError/TrainSetCount, TestError/TestSetCount);
  free (Output);

}


void EvaluateNet(NET* Net)
{
  INT  Count,Begin;
  REAL* Output;
  REAL EvaluateError;

  Output = (REAL*)  calloc(M, sizeof(REAL));
  fprintf(f, "\n\n\n");
  fprintf(f, "number       fact          Prediction \n");
  fprintf(f, "\n");
  EvaluateError=0;
  Begin =(INT) floor(TestSetCount*0.5);
  for (Count=Begin; Count<=TestSetCount; Count++) {
    SimulateNet(Net, TestInput[Count], Output, TestTarget[Count], FALSE);
    ReverseNormalizeData(TestTarget[Count],1);
    ReverseNormalizeData(Output,0);
    fprintf(f, "%3d       %0.8f        %0.8f\n",
               Count-Begin+1,
               TestTarget[Count][1],
               Output [0]);
  EvaluateError     +=sqr(TestTarget[Count][1] - Output[0]);
  }
  fprintf(f, "The MSE =   %0.7f \n",EvaluateError/(TestSetCount-Begin+1));
  free (Output);
}


/*
void EvaluateNet(NET* Net)
{
  INT  Year;
  REAL Output [M];
  REAL Output_[M];

  fprintf(f, "\n\n\n");
  fprintf(f, "Year    Sunspots    Open-Loop Prediction    Closed-Loop Prediction\n");
  fprintf(f, "\n");
  for (Year=EVAL_LWB; Year<=EVAL_UPB; Year++) {
    SimulateNet(Net, &(Sunspots [Year-N]), Output,  &(Sunspots [Year]), FALSE);
    SimulateNet(Net, &(Sunspots_[Year-N]), Output_, &(Sunspots_[Year]), FALSE);
    Sunspots_[Year] = Output_[0];
    fprintf(f, "%d       %0.3f                   %0.3f                     %0.3f\n",
               FIRST_YEAR + Year,
               Sunspots[Year],
               Output [0],
               Output_[0]);
  }
}
*/

/******************************************************************************
                                    主函数

 ******************************************************************************/

/*
void main()
{
  NET  Net;
  BOOL Stop;
  REAL MinTestError;

  InitializeRandoms();
  GenerateNetwork(&Net);
  RandomWeights(&Net);
  InitializeApplication(&Net);

  Stop = FALSE;
  MinTestError = MAX_REAL;
  do {
    TrainNet(&Net, 10);
    TestNet(&Net);
    if (TestError < MinTestError) {
      fprintf(f, " - saving Weights ...");
      MinTestError = TestError;
      SaveWeights(&Net);
    }
    else if (TestError > 1.2 * MinTestError) {
      fprintf(f, " - stopping Training and restoring Weights ...");
      Stop = TRUE;
      RestoreWeights(&Net);
    }
  } while (NOT Stop);

  TestNet(&Net);
  EvaluateNet(&Net);
  
  FinalizeApplication(&Net);
}
*/
int main()
{
  NET  Net;//网络变量声明 
  BOOL Stop;//学习是否结束的控制变量 
  REAL MinTestError, MinTrainMSE;
  INT  Epoch;

 
  if(ReadData()==FALSE){
     printf(" Please press any key to ESC.");
     getch();
    return 0;
  }

  InitializeRandoms();//生成随机数 
  GenerateNetwork(&Net);//创建网络并初始化网络，分配空间 
  RandomWeights(&Net);//初始化网络联接权  

  InitializeApplication(&Net);//初始化输入层，将学习样本转换成输入模式  

  Stop = FALSE;
  MinTestError  = MAX_REAL;
  MinTrainMSE   = MAX_REAL;
  Epoch=0;
  printf("Begin to train BP net,please wait....\n");
  do {
    TrainNet(&Net, 10);
    TestNet(&Net);
    if (TestError < MinTestError) {
      fprintf(f, " - saving Parameters ...");
      MinTestError  = TestError;
      SaveWeights(&Net);//学习结束后保存宝贵的联接权 
    }
    else if (TestError > 1.2 * MinTestError) {

    }
    MinTrainMSE  = TrainError /TrainSetCount;
    Epoch++;
    Stop=(MinTrainMSE <= TARGET_ERROR) || (Epoch >= MAXEPOCHS);
  }  while (!Stop);
   fprintf(f, "\n - stopping Training at %d epoch and restoring Parameters ...",Epoch);
   RestoreWeights(&Net);

  TestNet(&Net);

  EvaluateNet(&Net);

  FinalizeApplication(&Net);//关闭文件 
  printf("It is over. The result is in BasicBPN.txt. \nPlease enter any key .....\n");
  getch();

  return 1;
}

先说一下我的毕设题目：RNAi片段的设计
我要做的编程分为3步：
第一步：读入一个txt文档，里面是长度可能几千的RNA序列：acgun……之类。根据MPI准则筛选出每条aa开头长度19并符合一定条件的序列放入另一个txt中。
第二步：读入刚才的结果，对每一条长度19的序列进行计算，得到6个特征值，输出到一个新的txt中，格式如：1.1 2.2 3.3 4.4 5.5 6.6
第三步：将刚才的特征向量作为输入进到BP神经网络里，这里还要分为2步：训练和测试。
前两步我做完了，现在有问题的是第三步，关于BP神经网络中的问题，纠结死我了……不会发图，好心人麻烦自己百度一下BP神经网络的结构吧……感觉我自己的问题也说不清楚了……
然后，现在我有了一个别人应用BP神经网络预测太阳黑子的框架，我要改动它的几个部分，但我自己做的有一堆错，希望好心人帮我改改看：
1.一个是读文件部分：我需要改成三个读文件的子程序，一个用于训练，两个用于测试。用于训练的子程序读的txt文件中格式是1.1 2.2 3.3 4.4 5.5 6.6 1（最后一个数字是BP神经网络的实际输出），用于测试的子程序读的就是第二步出来的txt和记载权值的txt（见2）。
2.一个是输出文件的部分：我需要改成2个输出子程序：训练之后要输出一个记载权值的txt文档，用于之后测试的时候载入权值。测试之后要输出一个带有序列编号和预测评分的txt文档。
3.自然是主函数，把刚才一系列理顺……
然后那个太阳黑子预测的程序我贴出来，我打了一些主要的注释。
我也觉得这个让大家看很考验大家，麻烦了……应该会有很多不懂吧，可以上QQ找我413084331，谢谢了！

我菜.我不懂.

求楼主赐教神经网络相关知识

给多少钱？

BP神经网络的意思是这样：
一个神经现在得到的信号，是由之前很多个神经传送过来的，那些神经有近有远，所以对现在这个神经的影响强弱也不同。
BP神经网络就是模拟神经的这种结构，假设有3层以上的神经元，第一层是输入层，输入前面的某些传过来的特征向量；中间的层称为隐藏层（隐层），是一个过渡；最后那层称为输出层，也就是你最后那个神经元得到的结果。我自己要做的程序有3层，输入层有6个，隐层6个，输出层1个神经元。BP算法是这样的：首先是训练，拿一些已知的特征向量和实际输出作为参数来训练网络，网络中某一个神经元的值是之前一层所有神经元的值各自乘以权值的叠加。训练的过程是这样：先随机生成权值，然后将第一条特征向量组和实际结果输入，比对由权值得出的结果和实际结果的差距，有一个反馈信号回过去，改变所有权值，之后再进第二条特征向量组和实际结果，一直这么来回往复，最后使预测结果和实际结果的误差小于指定数，这时候保存权值，这就完成训练了。其次是测试，就直接输入特征向量组，让BP网络进行运算，得到一个预测的值，这其实就是BP神经网络的应用了。
不知道这么说你明不明白，我没办法上图，这么说有点复杂，麻烦你这么帮我看了。

不明白市场价，你开价吧……偷偷摸摸告诉我，看我付得起不……谢谢~

那也谢谢你了，来帮我看这个帖子~

我看不懂

表示很有鸭梨。

给钱请高手帮忙吧