som神经网络c程序

最新推荐文章于 2021-05-19 03:52:02 发布
最新推荐文章于 2021-05-19 03:52:02 发布
阅读量1.6k 收藏 4
点赞数 
 Network:      Self-Organizing Map
                      ===================
 
        Application:  Control
                      Pole Balancing Problem
 
        Author:       Karsten Kutza
        Date:         6.6.96
 
        Reference:    T. Kohonen    
                      Self-Organized Formation
                      of Topologically Correct Feature Maps
                      Biological Cybernetics, 43, pp. 59-69, 1982
 
 ******************************************************************************/
 
 
 
 
/******************************************************************************
                            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 PI            (2*asin(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**        Weight;        /* - connection weights to ith unit      */
        REAL*         StepSize;      /* - size of search steps of ith unit    */
        REAL*         dScoreMean;    /* - mean score delta of ith unit        */
} LAYER;
 
typedef struct {                     /* A NET:                                */
        LAYER*        InputLayer;    /* - input layer                         */
        LAYER*        KohonenLayer;  /* - Kohonen layer                       */
        LAYER*        OutputLayer;   /* - output layer                        */
        INT           Winner;        /* - last winner in Kohonen layer        */
        REAL          Alpha;         /* - learning rate for Kohonen layer     */
        REAL          Alpha_;        /* - learning rate for output layer      */
        REAL          Alpha__;       /* - learning rate for step sizes        */
        REAL          Gamma;         /* - smoothing factor for score deltas   */
        REAL          Sigma;         /* - parameter for width of neighborhood */
} 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(4715);
}      
 
 
REAL RandomEqualREAL(REAL Low, REAL High)
{
  return ((REAL) rand() / RAND_MAX) * (High-Low) + Low;
}      
 
 
REAL RandomNormalREAL(REAL Mu, REAL Sigma)
{
  REAL x,fx;
 
  do {
    x = RandomEqualREAL(Mu-3*Sigma, Mu+3*Sigma);
    fx = (1 / (sqrt(2*PI)*Sigma)) * exp(-sqr(x-Mu) / (2*sqr(Sigma)));
  } while (fx < RandomEqualREAL(0, 1));
  return x;
}      
 
 
/******************************************************************************
               A P P L I C A T I O N - S P E C I F I C   C O D E
 ******************************************************************************/
 
 
#define ROWS          25
#define COLS          25
 
#define N             2
#define C             (ROWS * COLS)
#define M             1
 
#define TRAIN_STEPS   10000
#define BALANCED      100
 
FILE*                 f;
 
 
void InitializeApplication(NET* Net)
{
  INT i;
    
  for (i=0; i<Net->KohonenLayer->Units; i++) {
    Net->KohonenLayer->StepSize[i] = 1;
    Net->KohonenLayer->dScoreMean[i] = 0;
  }
  f = fopen("SOM.txt", "w");
}
 
 
void WriteNet(NET* Net)
{
  INT  r,c;
  REAL x,y,z;
 
  fprintf(f, "nnn");
  for (r=0; r<ROWS; r++) {
    for (c=0; c<COLS; c++) {
      x = Net->KohonenLayer->Weight[r*ROWS+c][0];
      y = Net->KohonenLayer->Weight[r*ROWS+c][1];
      z = Net->OutputLayer->Weight[0][r*ROWS+c];
      fprintf(f, "([%5.1f? %5.1f癩, %5.1fN)    ", x, y, z);
    }
    fprintf(f, "n");
  }
}
 
 
void FinalizeApplication(NET* Net)
{
  fclose(f);
}
 
 
/******************************************************************************
                     S I M U L A T I N G   T H E   P O L E
 ******************************************************************************/
 
                                     /* SIMULATION PARAMETERS FOR THE POLE:   */
#define L             1              /* - length of pole [m]                  */
#define Mc            1              /* - mass of cart [kg]                   */
#define Mp            1              /* - mass of pole [kg]                   */
#define G             9.81           /* - acceleration due to gravity [m/s瞉  */
#define T             0.1            /* - time step [s]                       */
#define STEPS         10             /* - simulation steps in one time step   */
 
 
typedef struct {                     /* STATE VARIABLES OF A POLE:            */
        REAL          x;             /* - position of cart [m]                */
        REAL          xDot;          /* - velocity of cart [m/s]              */
        REAL          w;             /* - angle of pole [癩                   */
        REAL          wDot;          /* - angular velocity of pole [?s]      */
        REAL          F;             /* - force applied to cart               */
} POLE;                              /*   during current time step [N]        */
 
 
void InitializePole(POLE* Pole)
{
  do {
    Pole->x    = 0;
    Pole->xDot = 0;
    Pole->w    = RandomEqualREAL(-30, 30);
    Pole->wDot = 0;
    Pole->F    = 0;
  } while (Pole->w == 0);
}
 
 
void SimulatePole(POLE* Pole)
{
  INT  s;
  REAL x, xDot, xDotDot;           
  REAL w, wDot, wDotDot;                   
  REAL F;                    
 
  x    = Pole->x;
  xDot = Pole->xDot;
  w    = (Pole->w    / 180) * PI;
  wDot = (Pole->wDot / 180) * PI;
  F    = Pole->F;
  for (s=0; s<STEPS; s++) {
 
    wDotDot = (G*sin(w) + cos(w) * ((-F - Mp*L*sqr(wDot)*sin(w)) / (Mc+Mp))) / 
              (L * ((REAL) 4/3 - (Mp*sqr(cos(w))) / (Mc+Mp)));
 
    xDotDot = (F + Mp*L * (sqr(wDot)*sin(w) - wDotDot*cos(w))) / (Mc+Mp);
 
    x    += (T / STEPS) * xDot;
    xDot += (T / STEPS) * xDotDot;
    w    += (T / STEPS) * wDot;
    wDot += (T / STEPS) * wDotDot;
  }
  Pole->x    = x;
  Pole->xDot = xDot;
  Pole->w    = (w    / PI) * 180;
  Pole->wDot = (wDot / PI) * 180;
}
 
 
BOOL PoleStillBalanced(POLE* Pole)
{
  return (Pole->w >= -60) AND (Pole->w <= 60);
}
 
 
REAL ScoreOfPole(POLE* Pole)
{
  return -sqr(Pole->w);
}
 
 
/******************************************************************************
                          I N I T I A L I Z A T I O N
 ******************************************************************************/
 
 
void GenerateNetwork(NET* Net)
{
  INT i;
 
  Net->InputLayer   = (LAYER*) malloc(sizeof(LAYER));
  Net->KohonenLayer = (LAYER*) malloc(sizeof(LAYER));
  Net->OutputLayer  = (LAYER*) malloc(sizeof(LAYER));
 
  Net->InputLayer->Units        = N;
  Net->InputLayer->Output       = (REAL*)  calloc(N, sizeof(REAL));
       
  Net->KohonenLayer->Units      = C;
  Net->KohonenLayer->Output     = (REAL*)  calloc(C, sizeof(REAL));
  Net->KohonenLayer->Weight     = (REAL**) calloc(C, sizeof(REAL*));
  Net->KohonenLayer->StepSize   = (REAL*)  calloc(C, sizeof(REAL));
  Net->KohonenLayer->dScoreMean = (REAL*)  calloc(C, sizeof(REAL));
       
  Net->OutputLayer->Units       = M;
  Net->OutputLayer->Output      = (REAL*)  calloc(M, sizeof(REAL));
  Net->OutputLayer->Weight      = (REAL**) calloc(M, sizeof(REAL*));
       
  for (i=0; i<C; i++) {
    Net->KohonenLayer->Weight[i] = (REAL*) calloc(N, sizeof(REAL));
  }
  for (i=0; i<M; i++) {
    Net->OutputLayer->Weight[i] = (REAL*) calloc(C, sizeof(REAL));
  }
}
 
 
void RandomWeights(NET* Net)
{
  INT i,j;
    
  for (i=0; i<Net->KohonenLayer->Units; i++) {
    for (j=0; j<Net->InputLayer->Units; j++) {
      Net->KohonenLayer->Weight[i][j] = RandomEqualREAL(-30, 30);
    }
  }
  for (i=0; i<Net->OutputLayer->Units; i++) {
    for (j=0; j<Net->KohonenLayer->Units; j++) {
      Net->OutputLayer->Weight[i][j] = 0;
    }
  }
}
 
 
void SetInput(NET* Net, REAL* Input)
{
  INT i;
    
  for (i=0; i<Net->InputLayer->Units; i++) {
    Net->InputLayer->Output[i] = Input[i];
  }
}
 
 
void GetOutput(NET* Net, REAL* Output)
{
  INT i;
    
  for (i=0; i<Net->OutputLayer->Units; i++) {
    Output[i] = Net->OutputLayer->Output[i];
  }
}
 
 
/******************************************************************************
                     P R O P A G A T I N G   S I G N A L S
 ******************************************************************************/
 
 
void PropagateToKohonen(NET* Net)
{
  INT  i,j;
  REAL Out, Weight, Sum, MinOut;
 
  for (i=0; i<Net->KohonenLayer->Units; i++) {
    Sum = 0;
    for (j=0; j<Net->InputLayer->Units; j++) {
      Out = Net->InputLayer->Output[j];
      Weight = Net->KohonenLayer->Weight[i][j];
      Sum += sqr(Out - Weight);
    }
    Net->KohonenLayer->Output[i] = sqrt(Sum);
  }
  MinOut = MAX_REAL;
  for (i=0; i<Net->KohonenLayer->Units; i++) {
    if (Net->KohonenLayer->Output[i] < MinOut)
      MinOut = Net->KohonenLayer->Output[Net->Winner = i];
  }
}
 
 
void PropagateToOutput(NET* Net)
{
  INT i;
 
  for (i=0; i<Net->OutputLayer->Units; i++) {
    Net->OutputLayer->Output[i] = Net->OutputLayer->Weight[i][Net->Winner];
  }
}
 
 
void PropagateNet(NET* Net)
{
  PropagateToKohonen(Net);
  PropagateToOutput(Net);
}
 
 
/******************************************************************************
                        T R A I N I N G   T H E   N E T
 ******************************************************************************/
 
 
REAL Neighborhood(NET* Net, INT i)
{
  INT  iRow, iCol, jRow, jCol;
  REAL Distance;
 
  iRow = i / COLS; jRow = Net->Winner / COLS;
  iCol = i % COLS; jCol = Net->Winner % COLS;
 
  Distance = sqrt(sqr(iRow-jRow) + sqr(iCol-jCol));
 
  return exp(-sqr(Distance) / (2*sqr(Net->Sigma)));
}
 
 
void TrainKohonen(NET* Net, REAL* Input)
{
  INT  i,j;
  REAL Out, Weight, Lambda, StepSize;
 
  for (i=0; i<Net->KohonenLayer->Units; i++) {
    for (j=0; j<Net->InputLayer->Units; j++) {
      Out = Input[j];
      Weight = Net->KohonenLayer->Weight[i][j];
      Lambda = Neighborhood(Net, i);
      Net->KohonenLayer->Weight[i][j] += Net->Alpha * Lambda * (Out - Weight);
    }
    StepSize = Net->KohonenLayer->StepSize[i];
    Net->KohonenLayer->StepSize[i] += Net->Alpha__ * Lambda * -StepSize;
  }
}
 
 
void TrainOutput(NET* Net, REAL* Output)
{
  INT  i,j;
  REAL Out, Weight, Lambda;
 
  for (i=0; i<Net->OutputLayer->Units; i++) {
    for (j=0; j<Net->KohonenLayer->Units; j++) {
      Out = Output[i];
      Weight = Net->OutputLayer->Weight[i][j];
      Lambda = Neighborhood(Net, j);
      Net->OutputLayer->Weight[i][j] += Net->Alpha_ * Lambda * (Out - Weight);
    }
  }
}
 
 
void TrainUnits(NET* Net, REAL* Input, REAL* Output)
{
  TrainKohonen(Net, Input);
  TrainOutput(Net, Output);
}
 
 
void TrainNet(NET* Net)
{
  INT  n,t;
  POLE Pole;
  REAL wOld, wNew, ScoreOld, ScoreNew, dScore, dScoreMean, StepSize;
  REAL Input[N];
  REAL Output[M];
  REAL Target[M];
 
  n = 0;
  while (n<TRAIN_STEPS) {
    t = 0;
    InitializePole(&Pole);
    fprintf(f, " Time     Angle     Forcen");
    fprintf(f, "%4.1fs    %5.1f?   %5.1fNn", t * T, Pole.w, Pole.F);
    wOld = Pole.w;
    ScoreOld = ScoreOfPole(&Pole);
    SimulatePole(&Pole);
    wNew = Pole.w;
    ScoreNew = ScoreOfPole(&Pole);
    while (PoleStillBalanced(&Pole) AND (t<BALANCED)) {
      n++;
      t++;
      Net->Alpha   = 0.5 * pow(0.01, (REAL) n / TRAIN_STEPS);
      Net->Alpha_  = 0.5 * pow(0.01, (REAL) n / TRAIN_STEPS);
      Net->Alpha__ = 0.005;
      Net->Gamma   = 0.05;
      Net->Sigma   = 6.0 * pow(0.2, (REAL) n / TRAIN_STEPS);
      Input[0] = wOld;
      Input[1] = wNew;
      SetInput(Net, Input);
      PropagateNet(Net);
      GetOutput(Net, Output);
      Pole.F = Output[0];
      StepSize = Net->KohonenLayer->StepSize[Net->Winner];
      Pole.F += StepSize * RandomNormalREAL(0, 10);
      fprintf(f, "%4.1fs    %5.1f?   %5.1fNn", t * T, Pole.w, Pole.F);
      wOld = Pole.w;
      ScoreOld = ScoreOfPole(&Pole);
      SimulatePole(&Pole);
      wNew = Pole.w;
      ScoreNew = ScoreOfPole(&Pole);
      dScore = ScoreNew - ScoreOld;
      dScoreMean = Net->KohonenLayer->dScoreMean[Net->Winner];
      if (dScore > dScoreMean) {
        Target[0] = Pole.F;
        TrainUnits(Net, Input, Target);
      }
      Net->KohonenLayer->dScoreMean[Net->Winner] += Net->Gamma * (dScore - dScoreMean);
    }
    if (PoleStillBalanced(&Pole))
      fprintf(f, "Pole still balanced after %0.1fs ...nn", t * T);
    else
      fprintf(f, "Pole fallen after %0.1fs ...nn", (t+1) * T);
  }
}
 
 
/******************************************************************************
                                    M A I N
 ******************************************************************************/
 
 
void main()
{
  NET Net;
 
  InitializeRandoms();
  GenerateNetwork(&Net);
  RandomWeights(&Net);
  InitializeApplication(&Net);
  TrainNet(&Net);
  WriteNet(&Net);
  FinalizeApplication(&Net);
}
liujiaoatcd
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
som神经网络C 代码（网上的）
06-22
som神经网络的c程序例子。下载后用Notepad++打开就行，或者自己改下格式
SOM神经网络程序
05-14
SOM神经网络，matlab实现程序 可以进行数据分类 ，数据预测等功能
SOM神经网络分类程序
09-19
SOM神经网络分类程序
用C语言实现的神经网络SOM算法
10-31
一个用C语言实现的神经网络的SOM算法程序,欢迎大家下载
SOM自组织神经网络C++实现代码
12-11
本资源将SOM自组织神经网络算法通过C++语言进行编程实现，可以导入数据直接运行
SOM.rar_SOM_som神经网络
09-21
总之，这个"SOM.rar"压缩包提供了一个用C语言实现的SOM神经网络算法的源代码，对于理解SOM的工作原理、进行数据可视化和降维分析具有很高的价值。通过学习和调试这个源代码，开发者可以深入掌握无监督学习中的一个...
c语言编写的神经网络源程序
11-13
标题 "c语言编写的神经网络源程序" 描述了使用C语言实现的神经网络算法，这是一种基础且高效的编程语言，适合在嵌入式系统中应用。C语言的灵活性和低级特性使其成为编写高效神经网络代码的理想选择，尤其是在资源...
som神经网络的代码，欢迎下载
10-22
根据给定的部分代码，我们可以看到这是SOM神经网络的一个C语言实现。这段代码主要包含以下几个部分： 1. **头文件包含与类型定义：** - `#include <stdlib.h>`、`#include <stdio.h>` 和 `#include <math.h>` 分别...
SOM自组织神经网络
Marshall的专栏
10-19 1194
自组织神经网络介绍：自组织特征映射SOM(Self-organizing feature Map)，第一部分 自组织神经网络介绍：自组织特征映射SOM(Self-organizing feature Map)，第二部分 自组织神经网络介绍：自组织特征映射SOM(Self-organizing feature Map)，第三部分
som神经网络程序例子
03-03
这是神经网络SOM的一例子，包括其程序，供初学者使用
一个很好的SOM程序代码
04-18
该程序具体用一神经网络SOM实现了倒立摆的平衡控制，并取得了很好的效果。
SOM神经网络.zip
09-23
这个压缩包包含 SOM神经网络的讲解PPT、一个SOM神经网络的应用实例和神经网络工具箱文档
神经网络算法源程序(用c++编写,有SOM,HOPFIELD等)
12-07
神经网络算法源程序，如SOM、HOPFIELD、CPN、BPN、BOLTZMAN、ART、ADALINE，同时提供针对不同算法的演示源程序。
SOM神经网络的应用
12-14
这是SOM神经网络在人力资源方面的应用，体现的SOM网络的分类功能。
SOM网络
逐波与逆流
02-13 5664
SOM网络的训练方法    SOM神经网络采用的算法称为Kohonen算法，它的基本思想是：网络输出层的各神经元通过竞争来获得对输入层的响应机会，最后只有一个神经元获胜。获胜的神经元对它临近的神经元的影响由近及远，由兴奋逐渐转为抑制，那些与获胜神经元有关的各连接权朝着有利于它竞争的方向转变。  SOM网络的算法如下： (1)初始化  对输出层各权向量赋予较小的随机数并进行归一化处理,得到,
SOM神经网络小记
u010375739的专栏
04-01 3077
SOM神经网络也属于自组织型学习网络，只不过更特殊一点它属于自组织特征的映射网络。该网络是由一个全连接的神经元阵列组成的无教师，自组织，自学习的网络。kohonen认为，处于空间中不同区域的神经元有着不同的分工，当一个神经网络接受外界输入模式时，将会分为不同的反映域，各区域对于输入模式具有不同的相应特征。 它与竞争层网络的区别是在SOM神经网络中既可以学习训练数据输入向量的分布特征，也可以学习训
神经网络 c语言实现,神经网络c语言实现
weixin_36378669的博客
05-19 2790
#include "stdio.h"#includeconst double e = 2.7182818;实验结果//设置一个神经网络//有一个隐藏层(含有两个节点)//输出层有一个节点//输入数据是二维(两个节点)//一个样本数据为：x = (0.35,0.9) 标签为0.5//初始权值输入节点1到隐藏层：0.1，0.4//输入节点2到隐藏层：0.8,0.6//隐藏层到输出层初始权值为：0.3...
竞争神经网络和Som神经网络
最新发布
02-03
竞争神经网络（Competitive Neural Networks）和SOM神经网络（Self-Organizing Maps）都是常见的神经网络模型，用于解决不同类型的问题。 竞争神经网络是一种无监督学习模型，它模拟了生物神经系统中的竞争机制。它的目标是通过竞争和合作来实现输入数据的分类和聚类。竞争神经网络通常由一组竞争单元组成，每个单元代表一个类别或聚类中心。输入数据与这些单元进行竞争，并最终被分配给最匹配的单元。常见的竞争神经网络包括自适应共振理论（ART）和Kohonen自组织特征映射（SOFM）。 SOM神经网络是一种无监督学习模型，用于将高维输入数据映射到低维空间中。它通过自组织的方式将相似的输入数据映射到相邻的神经元上，从而形成一个拓扑有序的映射。SOM神经网络通常由一个二维或三维的神经元网格组成，每个神经元代表一个低维空间中的位置。输入数据通过竞争机制选择最匹配的神经元，并通过更新权重来调整神经元之间的拓扑关系。SOM神经网络在数据可视化、聚类分析和特征提取等领域有广泛应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值