BP神经网络C程序

最新推荐文章于 2022-08-29 14:30:24 发布
最新推荐文章于 2022-08-29 14:30:24 发布
阅读量1.3k 收藏 1
点赞数 
/******************************************************************************

                      ====================================================
        Network:      Backpropagation Network with Bias Terms and Momentum
                      ====================================================

        Application:  Time-Series Forecasting
                      Prediction of the Annual Number of Sunspots

        Author:       Karsten Kutza
        Date:         17.4.96

        Reference:    D.E. Rumelhart, G.E. Hinton, R.J. Williams
                      Learning Internal Representations by Error Propagation
                      in:
                      D.E. Rumelhart, J.L. McClelland (Eds.)
                      Parallel Distributed Processing, Volume 1
                      MIT Press, Cambridge, MA, pp. 318-362, 1986

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




/******************************************************************************
                            D E C L A R A T I O N S
 ******************************************************************************/


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


typedef int           BOOL;
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 {                     /* A LAYER OF A NET:                     */
        INT           Units;         /* - number of units in this layer       */
        REAL*         Output;        /* - output of ith unit                  */
        REAL*         Error;         /* - error term of ith unit              */
        REAL**        Weight;        /* - connection weights to ith unit      */
        REAL**        WeightSave;    /* - saved weights for stopped training  */
        REAL**        dWeight;       /* - last weight deltas for momentum     */
} LAYER;

typedef struct {                     /* A NET:                                */
        LAYER**       Layer;         /* - layers of this net                  */
        LAYER*        InputLayer;    /* - input layer                         */
        LAYER*        OutputLayer;   /* - output layer                        */
        REAL          Alpha;         /* - momentum factor                     */
        REAL          Eta;           /* - learning rate                       */
        REAL          Gain;          /* - gain of sigmoid function            */
        REAL          Error;         /* - total net error                     */
} NET;


/******************************************************************************
        R A N D O M S   D R A W N   F R O M   D I S T R I B U T I O N S
 ******************************************************************************/


void InitializeRandoms()
{
  srand(4711);
}


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


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


/******************************************************************************
               A P P L I C A T I O N - S P E C I F I C   C O D E
 ******************************************************************************/


#define NUM_LAYERS    3
#define N             30
#define M             1
INT                   Units[NUM_LAYERS] = {N, 10, M};

#define FIRST_YEAR    1700
#define NUM_YEARS     280

#define TRAIN_LWB     (N)
#define TRAIN_UPB     (179)
#define TRAIN_YEARS   (TRAIN_UPB - TRAIN_LWB + 1)
#define TEST_LWB      (180)
#define TEST_UPB      (259)
#define TEST_YEARS    (TEST_UPB - TEST_LWB + 1)
#define EVAL_LWB      (260)
#define EVAL_UPB      (NUM_YEARS - 1)
#define EVAL_YEARS    (EVAL_UPB - EVAL_LWB + 1)

REAL                  Sunspots_[NUM_YEARS];
REAL                  Sunspots [NUM_YEARS] = {

                        0.0262,  0.0575,  0.0837,  0.1203,  0.1883,  0.3033,  
                        0.1517,  0.1046,  0.0523,  0.0418,  0.0157,  0.0000,  
                        0.0000,  0.0105,  0.0575,  0.1412,  0.2458,  0.3295,  
                        0.3138,  0.2040,  0.1464,  0.1360,  0.1151,  0.0575,  
                        0.1098,  0.2092,  0.4079,  0.6381,  0.5387,  0.3818,  
                        0.2458,  0.1831,  0.0575,  0.0262,  0.0837,  0.1778,  
                        0.3661,  0.4236,  0.5805,  0.5282,  0.3818,  0.2092,  
                        0.1046,  0.0837,  0.0262,  0.0575,  0.1151,  0.2092,  
                        0.3138,  0.4231,  0.4362,  0.2495,  0.2500,  0.1606,  
                        0.0638,  0.0502,  0.0534,  0.1700,  0.2489,  0.2824,  
                        0.3290,  0.4493,  0.3201,  0.2359,  0.1904,  0.1093,  
                        0.0596,  0.1977,  0.3651,  0.5549,  0.5272,  0.4268,  
                        0.3478,  0.1820,  0.1600,  0.0366,  0.1036,  0.4838,  
                        0.8075,  0.6585,  0.4435,  0.3562,  0.2014,  0.1192,  
                        0.0534,  0.1260,  0.4336,  0.6904,  0.6846,  0.6177,  
                        0.4702,  0.3483,  0.3138,  0.2453,  0.2144,  0.1114,  
                        0.0837,  0.0335,  0.0214,  0.0356,  0.0758,  0.1778,  
                        0.2354,  0.2254,  0.2484,  0.2207,  0.1470,  0.0528,  
                        0.0424,  0.0131,  0.0000,  0.0073,  0.0262,  0.0638,  
                        0.0727,  0.1851,  0.2395,  0.2150,  0.1574,  0.1250,  
                        0.0816,  0.0345,  0.0209,  0.0094,  0.0445,  0.0868,  
                        0.1898,  0.2594,  0.3358,  0.3504,  0.3708,  0.2500,  
                        0.1438,  0.0445,  0.0690,  0.2976,  0.6354,  0.7233,  
                        0.5397,  0.4482,  0.3379,  0.1919,  0.1266,  0.0560,  
                        0.0785,  0.2097,  0.3216,  0.5152,  0.6522,  0.5036,  
                        0.3483,  0.3373,  0.2829,  0.2040,  0.1077,  0.0350,  
                        0.0225,  0.1187,  0.2866,  0.4906,  0.5010,  0.4038,  
                        0.3091,  0.2301,  0.2458,  0.1595,  0.0853,  0.0382,  
                        0.1966,  0.3870,  0.7270,  0.5816,  0.5314,  0.3462,  
                        0.2338,  0.0889,  0.0591,  0.0649,  0.0178,  0.0314,  
                        0.1689,  0.2840,  0.3122,  0.3332,  0.3321,  0.2730,  
                        0.1328,  0.0685,  0.0356,  0.0330,  0.0371,  0.1862,  
                        0.3818,  0.4451,  0.4079,  0.3347,  0.2186,  0.1370,  
                        0.1396,  0.0633,  0.0497,  0.0141,  0.0262,  0.1276,  
                        0.2197,  0.3321,  0.2814,  0.3243,  0.2537,  0.2296,  
                        0.0973,  0.0298,  0.0188,  0.0073,  0.0502,  0.2479,  
                        0.2986,  0.5434,  0.4215,  0.3326,  0.1966,  0.1365,  
                        0.0743,  0.0303,  0.0873,  0.2317,  0.3342,  0.3609,  
                        0.4069,  0.3394,  0.1867,  0.1109,  0.0581,  0.0298,  
                        0.0455,  0.1888,  0.4168,  0.5983,  0.5732,  0.4644,  
                        0.3546,  0.2484,  0.1600,  0.0853,  0.0502,  0.1736,  
                        0.4843,  0.7929,  0.7128,  0.7045,  0.4388,  0.3630,  
                        0.1647,  0.0727,  0.0230,  0.1987,  0.7411,  0.9947,  
                        0.9665,  0.8316,  0.5873,  0.2819,  0.1961,  0.1459,  
                        0.0534,  0.0790,  0.2458,  0.4906,  0.5539,  0.5518,  
                        0.5465,  0.3483,  0.3603,  0.1987,  0.1804,  0.0811,  
                        0.0659,  0.1428,  0.4838,  0.8127 

                      };

REAL                  Mean;
REAL                  TrainError;
REAL                  TrainErrorPredictingMean;
REAL                  TestError;
REAL                  TestErrorPredictingMean;

FILE*                 f;


void NormalizeSunspots()
{
  INT  Year;
  REAL Min, Max;
	
  Min = MAX_REAL;
  Max = MIN_REAL;
  for (Year=0; Year<NUM_YEARS; Year++) {
    Min = MIN(Min, Sunspots[Year]);
    Max = MAX(Max, Sunspots[Year]);
  }
  Mean = 0;
  for (Year=0; Year<NUM_YEARS; Year++) {
    Sunspots_[Year] = 
    Sunspots [Year] = ((Sunspots[Year]-Min) / (Max-Min)) * (HI-LO) + LO;
    Mean += Sunspots[Year] / NUM_YEARS;
  }
}


void InitializeApplication(NET* Net)
{
  INT  Year, i;
  REAL Out, Err;

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

  NormalizeSunspots();
  TrainErrorPredictingMean = 0;
  for (Year=TRAIN_LWB; Year<=TRAIN_UPB; Year++) {
    for (i=0; i<M; i++) {
      Out = Sunspots[Year+i];
      Err = Mean - Out;
      TrainErrorPredictingMean += 0.5 * sqr(Err);
    }
  }
  TestErrorPredictingMean = 0;
  for (Year=TEST_LWB; Year<=TEST_UPB; Year++) {
    for (i=0; i<M; i++) {
      Out = Sunspots[Year+i];
      Err = Mean - Out;
      TestErrorPredictingMean += 0.5 * sqr(Err);
    }
  }
  f = fopen("BPN.txt", "w");
}


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


/******************************************************************************
                          I N I T I A L I Z A T I O N
 ******************************************************************************/


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-1];
  }
}


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


/******************************************************************************
            S U P P O R T   F O R   S T O P P E D   T R A I N I N G
 ******************************************************************************/


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];
      }
    }
  }
}


/******************************************************************************
                     P R O P A G A T I N G   S I G N A L S
 ******************************************************************************/


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]);
  }
}


/******************************************************************************
                  B A C K P R O P A G A T I N G   E R R O R S
 ******************************************************************************/


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-1]-Out;
    Net->OutputLayer->Error[i] = Net->Gain * Out * (1-Out) * Err;
    Net->Error += 0.5 * sqr(Err);
  }
}


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];
    }
    Lower->Error[i] = Net->Gain * Out * (1-Out) * Err;
  }
}


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];
        Net->Layer[l]->Weight[i][j] += Net->Eta * Err * Out + Net->Alpha * dWeight;
        Net->Layer[l]->dWeight[i][j] = Net->Eta * Err * Out;
      }
    }
  }
}


/******************************************************************************
                      S I M U L A T I N G   T H E   N E T
 ******************************************************************************/


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  Year, n;
  REAL Output[M];

  for (n=0; n<Epochs*TRAIN_YEARS; n++) {
    Year = RandomEqualINT(TRAIN_LWB, TRAIN_UPB);
    SimulateNet(Net, &(Sunspots[Year-N]), Output, &(Sunspots[Year]), TRUE);
  }
}


void TestNet(NET* Net)
{
  INT  Year;
  REAL Output[M];

  TrainError = 0;
  for (Year=TRAIN_LWB; Year<=TRAIN_UPB; Year++) {
    SimulateNet(Net, &(Sunspots[Year-N]), Output, &(Sunspots[Year]), FALSE);
    TrainError += Net->Error;
  }
  TestError = 0;
  for (Year=TEST_LWB; Year<=TEST_UPB; Year++) {
    SimulateNet(Net, &(Sunspots[Year-N]), Output, &(Sunspots[Year]), FALSE);
    TestError += Net->Error;
  }
  fprintf(f, "\nNMSE is %0.3f on Training Set and %0.3f on Test Set",
             TrainError / TrainErrorPredictingMean,
             TestError / TestErrorPredictingMean);
}


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]);
  }
}


/******************************************************************************
                                    M A I N
 ******************************************************************************/


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);
}

liujiaoatcd
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
BP-PID程序
03-28
BP-PID程序 非常实用 可以直接运行，本人设计控制器多次用它
BP神经网络PID控制程序
09-05
BP神经网络PID控制，可以对预定数据进行快速跟踪，误差较小，路径可以根据自己需要设定。
BP_PID-master.7z
11-26
C语言 BPPID 代码非常珍贵！可移植实际工程应用， 例如 Wincc 项目中 项目函数使用。控制更上一层楼，也可以利用VS201x生成.dll文件 在 动作 全局动作中调用.dll文件，增加保密性！是你的人生更上一层楼！不是单独BP也不是单独PID，是BPPID！请工控人员、控制人员放心下载！懂得利用、应用、活用、现用。
神经网络PID控制源程序
05-05
很经典的神经网络控制源程序，使用BP算法，能直接使用，很有参考价值。
PRN（20200908）：Frosting Weights for Better Continual Training
昔风不起，唯有努力生存！
09-08 621
Zhu, Xiaofeng, et al. “Frosting Weights for Better Continual Training.” 2019 18th IEEE International Conference On Machine Learning And Applications (ICMLA). IEEE, 2019. 1. 问题背景 问题依旧是解决深度学习灾难性遗忘问题，详见深度学习之灾难性遗忘问题与PRN（20200816）：A Hierarchical Deep Convolutio
BP神经网络C程序1
08-08
总的来说，这个BP神经网络C程序展示了如何使用C语言实现神经网络的基本结构和学习过程，包括权重初始化、数据结构设计、学习算法优化以及文件操作。通过深入理解这些概念和代码实现，我们可以更好地掌握神经网络的...
BP神经网络C程序.rar_BP_BP 神经网络_神经
09-20
在本压缩包文件“BP神经网络C程序.rar”中，包含了一个用C++实现的BP神经网络实例，旨在帮助理解和应用这种网络模型。 BP神经网络的核心思想是通过反向传播算法来调整网络中的权重和偏置，以最小化预测输出与实际...
BP神经网络C语言工程
09-07
在这个“BP神经网络C语言工程”中，开发者提供了C语言实现的BP神经网络框架，使得该算法能够在单片机这样的嵌入式系统上运行，如STM32系列。 首先，我们来看看关键的源文件： 1. **BPNetwork.c**：这个文件包含了BP...
bp神经网络 C语言实现
02-02
BP（Backpropagation）神经...总之，这个C语言实现的BP神经网络库为机器学习爱好者和开发者提供了一个基础的工具，方便他们在C环境中实现和应用神经网络模型，同时也为学习和理解BP网络的内部工作机制提供了实践平台。
BPN.rar_BP神经网络_C语言程序_bp神经_bp神经网络c
09-19
**BP神经网络** BP（Back Propagation）神经网络是一种经典的多层前馈神经网络，它在机器学习领域中被广泛用于非线性模型的训练。该网络由输入层、隐藏层和输出层构成，其中隐藏层可以有多个。BP算法的核心在于通过...
加L2正则化防止过拟合前后准确率变化，以及权重初始化
accumulate_zhang的博客
12-15 5731
最近在看深度模型处理nlp文本分类。一般在写模型的时候，L2正则化系数设为0了，没有去跑正则化。还有一个小trick，就是一些权重的初始化，比如CNN每层的权重，以及全连接层的权重等等。 一般这些权重可能选择随机初始化，符合某种正态分布。虽然结果影响不大，但是肯定会影响模型收敛以及准确率的。 先上两张图。 第一张
PRN（20220826）：Learning to Prompt for Continual Learning (CVPR 2022)[理解不了篇]
昔风不起，唯有努力生存！
08-29 2149
Google AI提出来的这个新的可持续学习方法，说是通过增加一个可学习的提示池就能提升模型的可持续学习能力。本人表示很神奇，因为这种方法没有显示地利用历史信息时刻唤醒模型对历史知识的记忆，也没隐式的利用历史信息限制那些对历史知识重要的模型权重的更改。从这个提示池中，我隐约看到了聚类的影子，以为窥探到了方法的基理。用包含提示数据类别的信息与数据状态一起作为输入，能够提升可持续学习的能力。这是一个错误的猜想！！！那妖法到底施在哪儿了呢？......
Introduction to neural network —— C语言实现BP神经网络识别数字
Jason Leaster | Rebuilding the tower of babel
10-24 6057
Introduction to nerual network                  基本上玩过数模或者模式识别的研究生就会知道神经网络这个新兴的技术，当然多数人也就只会在matlab里面调用API而已，真正神经网络是什么，怎么实现的...就呵呵了. 仅有基础数据类型元素，没有过多的抽象的C语言实现的时候，才是真正把逻辑思维转化为可用，同时也是对自身逻辑思
Pommerman多智能体强化学习 Continual Match Based Training in Pommerman: Technical Report
不一样的烟火
11-21 1334
文章地址： https://arxiv.org/pdf/1812.07297.pdf ​ Pommerman 是NeurIPS会议上开设的多智能体竞赛，将多智能体协作、非完全信息博弈以及持续学习等关键问题浓缩到炸弹人这款竞赛中，鼓励全世界优秀的研发人员一起参加解决技术挑战。 ​ 本文是曾经在 The NeurIPS 2018 Pommerman Competition 中获得第一的团队发表的文章,...
BP神经网络C语言实现
热门推荐
qq_39545674的博客
09-07 2万+
BP神经网络C语言实现 山人 BP神经网络应用广泛，大概是今年的五月份左右，我需要做一个多元函数的拟合，所以写了这个BP神经网络。为什么要使用C语言来写呢？因为我的程序需要在单片机上跑，所以不得不使用C语言。 这一篇博客不会讲解BP神经网络的基本原理，反向传播公式，因为关于这些的资料网上已经很多了（虽然大多数都有着不小的BUG，但足以入门学习）。我会着重讲解我写的BP神经网络的每个函数的具体...
c 语言实现神经网络算法,神经网络BP算法(C程序实现)[转载]
weixin_30357183的博客
05-24 1563
文件输入输出目录为：F:\BP\训练样本文件名：训练样本.txt值为：11-11-110101输出文件名为：阈值.txt权值.txt＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝#include "stdlib.h"#include "math.h"#include "conio.h"#include "stdio.h"#define N 2 /*/学习样本个数*/#define IN 3 ...
Introduction to neural network —— 该“神经网络” 下拉“祭坛”
weixin_33912246的博客
09-25 132
Introduction to neural network          不能自欺欺人. 实干兴邦，空谈误国。 ---------------------------------------------------------------------------------------------------------------------------------...
人工神经网络 附书bp c语言程序
最新发布
10-21
人工神经网络是一种模拟人脑神经系统工作原理的计算模型，用于模拟人类智能的行为和思维过程。它由神经元和神经连接构成，通过改变神经元之间的连接权重来实现对输入信号的处理和输出结果的预测。 bp（反向传播）算法是人工神经网络中常用的训练算法之一。它通过将网络输出结果与预期结果之间的误差反向传播，调整神经元之间的连接权重，来达到减小误差的目的。bp算法的具体实现过程包含前向传播和反向传播两部分。 以C语言为例，以下是一个简单的bp算法的实现程序示例： ```c #include <stdio.h> #include <stdlib.h> #include <math.h> #define INPUT_NUM 2 #define HIDDEN_NUM 2 #define OUTPUT_NUM 1 #define LEARNING_RATE 0.5 #define MAX_ITERATIONS 10000 #define ERROR_THRESHOLD 0.0001 /* 定义神经网络结构 */ typedef struct { double input[INPUT_NUM]; // 输入层 double hidden[HIDDEN_NUM]; // 隐藏层 double output[OUTPUT_NUM]; // 输出层 double hidden_weights[HIDDEN_NUM][INPUT_NUM]; // 隐藏层权重 double output_weights[OUTPUT_NUM][HIDDEN_NUM]; // 输出层权重 } NeuralNetwork; /* sigmoid激活函数 */ double sigmoid(double x) { return 1 / (1 + exp(-x)); } /* sigmoid激活函数的导数 */ double sigmoid_derivative(double x) { return sigmoid(x) * (1 - sigmoid(x)); } /* 前向传播 */ void forward(NeuralNetwork *nn) { // 隐藏层计算 for (int i = 0; i < HIDDEN_NUM; i++) { double sum = 0.0; for (int j = 0; j < INPUT_NUM; j++) { sum += nn->input[j] * nn->hidden_weights[i][j]; } nn->hidden[i] = sigmoid(sum); } // 输出层计算 for (int i = 0; i < OUTPUT_NUM; i++) { double sum = 0.0; for (int j = 0; j < HIDDEN_NUM; j++) { sum += nn->hidden[j] * nn->output_weights[i][j]; } nn->output[i] = sigmoid(sum); } } /* 反向传播 */ void backward(NeuralNetwork *nn, double target_value) { // 输出层误差计算 double output_error[OUTPUT_NUM]; for (int i = 0; i < OUTPUT_NUM; i++) { output_error[i] = (target_value - nn->output[i]) * sigmoid_derivative(nn->output[i]); } // 隐藏层误差计算 double hidden_error[HIDDEN_NUM]; for (int i = 0; i < HIDDEN_NUM; i++) { double sum = 0.0; for (int j = 0; j < OUTPUT_NUM; j++) { sum += output_error[j] * nn->output_weights[j][i]; } hidden_error[i] = sum * sigmoid_derivative(nn->hidden[i]); } // 更新输出层权重 for (int i = 0; i < OUTPUT_NUM; i++) { for (int j = 0; j < HIDDEN_NUM; j++) { nn->output_weights[i][j] += LEARNING_RATE * output_error[i] * nn->hidden[j]; } } // 更新隐藏层权重 for (int i = 0; i < HIDDEN_NUM; i++) { for (int j = 0; j < INPUT_NUM; j++) { nn->hidden_weights[i][j] += LEARNING_RATE * hidden_error[i] * nn->input[j]; } } } /* 训练神经网络 */ void train(NeuralNetwork *nn, double input1, double input2, double target_value) { nn->input[0] = input1; nn->input[1] = input2; // 进行前向传播和反向传播 forward(nn); backward(nn, target_value); } int main() { NeuralNetwork nn; double input1, input2, target_value; int iterations = 0; // 初始化权重 for (int i = 0; i < HIDDEN_NUM; i++) { for (int j = 0; j < INPUT_NUM; j++) { nn.hidden_weights[i][j] = (double)rand() / RAND_MAX; } } for (int i = 0; i < OUTPUT_NUM; i++) { for (int j = 0; j < HIDDEN_NUM; j++) { nn.output_weights[i][j] = (double)rand() / RAND_MAX; } } // 训练神经网络 do { input1 = (double)rand() / RAND_MAX; input2 = (double)rand() / RAND_MAX; target_value = input1 + input2; train(&nn, input1, input2, target_value); iterations++; } while (iterations < MAX_ITERATIONS && nn.output[0] - target_value > ERROR_THRESHOLD); // 打印训练结果 printf("训练结果：\n"); printf("输入1: %.2f, 输入2: %.2f, 目标值: %.2f, 输出值: %.2f\n", input1, input2, target_value, nn.output[0]); return 0; } ``` 以上是一个简单的bp算法的神经网络训练程序示例，其中定义了一个具有2个输入神经元、2个隐藏神经元和1个输出神经元的神经网络结构，并通过随机初始化权重和输入数据，训练神经网络，最终输出训练结果。 请注意，以上示例只是一个简单的实现程序，实际应用中可能需要进一步优化和改进。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值