CPN神经网络C程序

最新推荐文章于 2021-05-30 22:23:19 发布
最新推荐文章于 2021-05-30 22:23:19 发布
阅读量884 收藏 1
点赞数 
/******************************************************************************
 
                      ==========================
        Network:      Counterpropagation Network
                      ==========================
 
        Application:  Vision
                      Determination of the Angle of Rotation
 
        Author:       Karsten Kutza
        Date:         30.4.96
 
        Reference:    R. Hecht-Nielsen
                      Counterpropagation Networks
                      Proceedings of the IEEE International Conference on
                      Neural Networks, II, IEEE Press, New York, NY, pp. 19-32,
                      1987
 
 ******************************************************************************/
 
 
 
 
/******************************************************************************
                            D E C L A R A T I O N S
 ******************************************************************************/
 
 
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <fstream.h>
 
 
typedef int           BOOL;
typedef char          CHAR;
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
#define HI            1
 
#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      */
        BOOL*         Winner;        /* - marker for winning instar           */
} LAYER;
 
typedef struct
{                                    /* A NET:                                */
        LAYER*        InputLayer;    /* - input layer                         */
        LAYER*        InstarLayer;   /* - instar layer                        */
        LAYER*        OutstarLayer;  /* - outstar layer                       */
        INT           Winners;       /* - allowed number of winning instars   */
        REAL          Alpha;         /* - hidden layer learning rate          */
        REAL          Beta;          /* - output layer learning rate          */
} 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;
}      
 
 
/******************************************************************************
               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_DATA      8
#define X             11
#define Y             11
 
#define N             (X * Y)
#define C             NUM_DATA
#define M             2
 
CHAR                  Pattern[NUM_DATA][Y][X] =  { { "           ",
                                                     "           ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "   OOOOO   ",
                                                     "   OOOOO   ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "        O  ",
                                                     "       O   ",
                                                     "     OOO   ",
                                                     "    OOO    ",
                                                     "   OOO     ",
                                                     " OOOOO     ",
                                                     "OOOOO      ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "           ",
                                                     "  OO       ",
                                                     "  OOOOO    ",
                                                     "  OOOOOOO  ",
                                                     "  OOOOO    ",
                                                     "  OO       ",
                                                     "           ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "OOOOO      ",
                                                     " OOOOO     ",
                                                     "   OOO     ",
                                                     "    OOO    ",
                                                     "     OOO   ",
                                                     "       O   ",
                                                     "        O  ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "   OOOOO   ",
                                                     "   OOOOO   ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "      OOOOO",
                                                     "     OOOOO ",
                                                     "     OOO   ",
                                                     "    OOO    ",
                                                     "   OOO     ",
                                                     "   O       ",
                                                     "  O        ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "           ",
                                                     "       OO  ",
                                                     "    OOOOO  ",
                                                     "  OOOOOOO  ",
                                                     "    OOOOO  ",
                                                     "       OO  ",
                                                     "           ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "  O        ",
                                                     "   O       ",
                                                     "   OOO     ",
                                                     "    OOO    ",
                                                     "     OOO   ",
                                                     "     OOOOO ",
                                                     "      OOOOO",
                                                     "           ",
                                                     "           "  } };
 
CHAR                  Pattern_[NUM_DATA][Y][X] = { { "           ",
                                                     "           ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "   OOOOO   ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "    O O    ",
                                                     "    O O    ",
                                                     "    O O    ",
                                                     "   O   O   ",
                                                     "   O   O   ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "           ",
                                                     "     O     ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "   OOOOO   ",
                                                     "           ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "           ",
                                                     "           ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "    OOO    ",
                                                     "           ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "  O        ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "    OOO    ",
                                                     "    OO     ",
                                                     "    OOO   O",
                                                     "    OOOO   ",
                                                     "   OOOOO   ",
                                                     "           ",
                                                     "       O   "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "     O     ",
                                                     "     O     ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "   OOOOO   ",
                                                     "   OOOOO   ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "       O   ",
                                                     "      O    ",
                                                     "    OOO    ",
                                                     "    OOO    ",
                                                     "   OOO     ",
                                                     "  OOOOO    ",
                                                     " OOOOO     ",
                                                     "           ",
                                                     "           "  },
 
                                                   { "           ",
                                                     "           ",
                                                     "        O  ",
                                                     "       O   ",
                                                     "     OOO   ",
                                                     "    OOO    ",
                                                     "   OOO     ",
                                                     " OOOOO     ",
                                                     "OOOOO      ",
                                                     "           ",
                                                     "           "  } };
                                                     
REAL                  Input [NUM_DATA][N];
REAL                  Input_[NUM_DATA][N];
REAL                  Output[NUM_DATA][M];
 
FILE*                 f;
//fstream f;
 
 
void NormalizeInput()
{
  INT  n,i;
  REAL Length, Length_;
 
  for (n=0; n<NUM_DATA; n++) 
  {
    Length  = 0;
    Length_ = 0;
    for (i=0; i<N; i++) 
    {
      Length  += sqr(Input [n][i]);
      Length_ += sqr(Input_[n][i]);
    }
    Length  = sqrt(Length);
    Length_ = sqrt(Length_);
    for (i=0; i<N; i++) 
    {
      Input [n][i] /= Length;
      Input_[n][i] /= Length_;
    }
  }
}
 
 
void InitializeApplication(NET* Net)
{
  INT n,i,j;
 
  for (n=0; n<NUM_DATA; n++) 
  {
    for (i=0; i<Y; i++) 
    {
      for (j=0; j<X; j++) 
      {
        Input [n][i*X+j] = (Pattern [n][i][j] == 'O') ? HI : LO;
        Input_[n][i*X+j] = (Pattern_[n][i][j] == 'O') ? HI : LO;
      }
    }
  }
  NormalizeInput();
  for (n=0; n<NUM_DATA; n++) 
  {
    Output[n][0] = sin(n * 0.25 * PI);
    Output[n][1] = cos(n * 0.25 * PI);
  }
  //f = fopen("CPN.txt", "w");
  f = fopen("out.txt", "w");
}
 
 
void WriteInput(NET* Net, REAL* Input)
{
  INT i;
    
  for (i=0; i<N; i++) 
  {
    if (i%X == 0) 
    {
        fprintf(f, "n");
        printf("n");
    }
    fprintf(f, "%c", (Input[i] != LO) ? 'O' : ' ');
    printf("%c",(Input[i] != LO) ? 'O' : ' ');
  }
  fprintf(f, " -> ");
  printf(" -> ");
}
 
 
void WriteOutput(NET* Net, REAL* Output)
{
  REAL Angle;
 
  Angle = (atan2(Output[0], Output[1]) / PI) * 180;
  if (Angle < 0)
    Angle = Angle + 360;
 
  fprintf(f, "%.2f度n", Angle);
  printf("%4.1f度n", Angle);
}
 
 
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 i;
 
  Net->InputLayer   = (LAYER*) malloc(sizeof(LAYER));
  Net->InstarLayer  = (LAYER*) malloc(sizeof(LAYER));
  Net->OutstarLayer = (LAYER*) malloc(sizeof(LAYER));
 
  Net->InputLayer->Units    = N;
  Net->InputLayer->Output   = (REAL*)  calloc(N, sizeof(REAL));
       
  Net->InstarLayer->Units   = C;
  Net->InstarLayer->Output  = (REAL*)  calloc(C, sizeof(REAL));
  Net->InstarLayer->Weight  = (REAL**) calloc(C, sizeof(REAL*));
  Net->InstarLayer->Winner  = (BOOL*)  calloc(C, sizeof(BOOL));
       
  Net->OutstarLayer->Units  = M;
  Net->OutstarLayer->Output = (REAL*)  calloc(M, sizeof(REAL));
  Net->OutstarLayer->Weight = (REAL**) calloc(M, sizeof(REAL*));
       
  for (i=0; i<C; i++) 
  {
    Net->InstarLayer->Weight[i] = (REAL*) calloc(N, sizeof(REAL));
  }
  for (i=0; i<M; i++) 
  {
    Net->OutstarLayer->Weight[i] = (REAL*) calloc(C, sizeof(REAL));
  }
 
  Net->Winners = 1;
  Net->Alpha   = 0.1;
  Net->Beta    = 0.1;
}
 
 
void SetInput(NET* Net, REAL* Input, BOOL Protocoling)
{
  INT i;
    
  for (i=0; i<Net->InputLayer->Units; i++) 
  {
    Net->InputLayer->Output[i] = Input[i];
  }
  if (Protocoling) 
  {
    WriteInput(Net, Input);
  }
}
 
 
void GetOutput(NET* Net, REAL* Output, BOOL Protocoling)
{
  INT i;
    
  for (i=0; i<Net->OutstarLayer->Units; i++) 
  {
    Output[i] = Net->OutstarLayer->Output[i];
  }
  if (Protocoling) 
  {
    WriteOutput(Net, Output);
  }
}
 
 
/******************************************************************************
                     P R O P A G A T I N G   S I G N A L S
 ******************************************************************************/
 
 
void PropagateToInstars(NET* Net)
{
  INT  w,i,j;
  REAL Sum, SumWinners, MaxOut;
  INT  Winner;
 
  for (i=0; i<Net->InstarLayer->Units; i++) 
  {
    Sum = 0;
    for (j=0; j<Net->InputLayer->Units; j++) 
    {
      Sum += Net->InstarLayer->Weight[i][j] * Net->InputLayer->Output[j];
    }
    Net->InstarLayer->Output[i] = Sum;
    Net->InstarLayer->Winner[i] = FALSE;
  }
  SumWinners = 0;
  for (w=0; w<Net->Winners; w++) 
  {
    MaxOut = MIN_REAL;
    for (i=0; i<Net->InstarLayer->Units; i++) 
    {
      if (NOT Net->InstarLayer->Winner[i] AND Net->InstarLayer->Output[i] > MaxOut)
      {
          Winner=i;
          MaxOut = Net->InstarLayer->Output[Winner];
        //MaxOut = Net->InstarLayer->Output[Winner = i];
      }
    }
    Net->InstarLayer->Winner[Winner] = TRUE;
    SumWinners += Net->InstarLayer->Output[Winner];
  }
  for (i=0; i<Net->InstarLayer->Units; i++) 
  {
    if (Net->InstarLayer->Winner[i])
      Net->InstarLayer->Output[i] = Net->InstarLayer->Output[i] / SumWinners;
    else
      Net->InstarLayer->Output[i] = 0;
  }
}
 
 
void PropagateToOutstars(NET* Net)
{
  INT  i,j;
  REAL Sum;
 
  for (i=0; i<Net->OutstarLayer->Units; i++) 
  {
    Sum = 0;
    for (j=0; j<Net->InstarLayer->Units; j++) 
    {  
      Sum += Net->OutstarLayer->Weight[i][j] * Net->InstarLayer->Output[j];
    }
    Net->OutstarLayer->Output[i] = Sum;
  }
}
 
 
void PropagateNet(NET* Net)
{
  PropagateToInstars(Net);
  PropagateToOutstars(Net);
}
 
 
/******************************************************************************
                        T R A I N I N G   T H E   N E T
 ******************************************************************************/
 
 
INT Winner(NET* Net)
{
  INT i;
 
  for (i=0; i<Net->InstarLayer->Units; i++) 
  {
    if (Net->InstarLayer->Winner[i])
      return i;
  }
}
 
 
void TrainInstars(NET* Net, INT Epochs)
{
  INT n,m,i,j;
    
  for (i=0; i<Net->InstarLayer->Units; i++) 
  {
    for (j=0; j<Net->InputLayer->Units; j++) 
    {
      Net->InstarLayer->Weight[i][j] = Input[i][j];
    }
  }
  Net->Winners = 1;
  for (m=0; m<Epochs*NUM_DATA; m++) 
  {
    n = RandomEqualINT(0, NUM_DATA-1);
    SetInput(Net, Input[n], FALSE);
    PropagateToInstars(Net);
    i = Winner(Net);
    for (j=0; j<Net->InputLayer->Units; j++) 
    {
      Net->InstarLayer->Weight[i][j] +=
        Net->Alpha * (Input[n][j] - Net->InstarLayer->Weight[i][j]);
    }
  }
}
 
 
void TrainOutstars(NET* Net, INT Epochs)
{
  INT n,m,i,j;
    
  for (i=0; i<Net->OutstarLayer->Units; i++) 
  {
    for (j=0; j<Net->InstarLayer->Units; j++) 
    {
      Net->OutstarLayer->Weight[i][j] = Output[j][i];
    }
  }
  Net->Winners = 1;
  for (m=0; m<Epochs*NUM_DATA; m++) 
  {
    n = RandomEqualINT(0, NUM_DATA-1);
    SetInput(Net, Input[n], FALSE);
    PropagateToInstars(Net);
    j = Winner(Net);
    for (i=0; i<Net->OutstarLayer->Units; i++) 
    {
      Net->OutstarLayer->Weight[i][j] +=
        Net->Beta * (Output[n][i] - Net->OutstarLayer->Weight[i][j]);
    }
  }
}
 
 
/******************************************************************************
                      S I M U L A T I N G   T H E   N E T
 ******************************************************************************/
 
 
void SimulateNet(NET* Net, REAL* Input)
{
  REAL Output[M];
 
  SetInput(Net, Input, TRUE);
  PropagateNet(Net);
  GetOutput(Net, Output, TRUE);
}
 
 
/******************************************************************************
                                    M A I N
 ******************************************************************************/
 
 
void main()
{
  NET Net;
  INT n;
 
  InitializeRandoms();
  GenerateNetwork(&Net);
  InitializeApplication(&Net);
  TrainInstars(&Net, 0);         /* weights are computed for this application */
  TrainOutstars(&Net, 0);        /* weights are computed for this application */
 
  Net.Winners = 2;
  for (n=0; n<NUM_DATA; n++) 
  {
    SimulateNet(&Net, Input[n]);
  }
  for (n=0; n<NUM_DATA; n++) 
  {
    SimulateNet(&Net, Input_[n]);
  }
 
  FinalizeApplication(&Net);
}

liujiaoatcd
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
对偶传播神经网络（CPN）
ZhangPY的专栏
08-15 6316
1987年，美国学者Robert Hecht-Nielsen提出了对偶传播神经网络模型 （Counter Propagation Network，CPN），CPN最早是用来实现样本选择匹配系统的。CPN 网能存储二进制或模拟值的模式对，因此这种网络模型也可用于联想存储、模式分类、函数逼近、统计分析和数据压缩等用途。 1.    网络结构与运行原理 网络结构如图所示，各层之间的神经元全互联连接。
CPN神经网络学习
Try_再努力一点
08-05 2811
CPN神经网络的一些资料： http://wenku.baidu.com/link?url=JIhrQ5tpegz_KfBEV6TT9nPL6SYBq-Msc8GzHJYgAi2rM462hTZy2QU4G7qUQYXlOdVxxHKn-FRKS5Ok9Jkc02gM2B72ySRrf9SM-mqZrT7 CPN神经网络设计步骤如下： C代码如下：（本代码按照步骤完成，同时也对照
对向传播神经网络（CPN）
qq_35912930的博客
05-30 619
这里写目录标题变极调速变频调速调节转差能耗调速转子电路串联电阻改变定子电压 变极调速 变频调速 调节转差能耗调速 转子电路串联电阻 改变定子电压
神经网络7种模型，如SOM、HOPFIELD、CPN、BPN、BOLTZMAN、RT、ADALINE
04-24
神经网络7种模型，如SOM、HOPFIELD、CPN、BPN、BOLTZMAN、ART、ADALINE 并带有人工神经网络入门讲稿.pdf
CPN人工神经网络例子源码
04-15
CPN人工神经网络例子源码，用c语言编写，提供给初学者练习
基于Matlab实现神经网络CPN算法（程序+数据）.rar
最新发布
07-19
1、资源内容：基于Matlab实现神经网络CPN算法（程序+数据）.rar 2、适用人群：计算机，电子信息工程、数学等专业的学习者，作为“参考资料”参考学习使用。 3、解压说明：本资源需要电脑端使用WinRAR、7zip等解压...
c语言编写的神经网络源程序
11-13
标题 "c语言编写的神经网络源程序" 描述了使用C语言实现的神经网络算法，这是一种基础且高效的编程语言，适合在嵌入式系统中应用。C语言的灵活性和低级特性使其成为编写高效神经网络代码的理想选择，尤其是在资源...
改进的CPN神经网络算法在流水线故障诊断中的应用.pdf
09-25
改进的CPN神经网络算法在流水线故障诊断中的应用 improves the CPN neural network algorithm in pipeline fault diagnosis, which can accurately identify the type of pipeline fault, and its processing ...
基于Matlab实现神经网络CPN算法（源码+数据）.rar
05-20
1、资源内容：基于Matlab实现神经网络CPN算法（源码+数据）.rar 2、适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 3、解压说明：本资源需要电脑端...
nnc.rar_NNC算法_cpn_hopfield_神经网络算法
09-24
这个压缩包“nnc.rar”涵盖了SOM（Self-Organizing Map，自组织映射）、HOPFIELD（霍夫菲尔德网络）、CPN（Cellular Programming and Neuro-Fuzzy System，细胞编程与神经模糊系统）、BPN（Backpropagation Network...
SOM神经网络、LVQ神经网络、CPN神经网络与Python实现
qq_41858347的博客
02-26 4302
竞争型学习神经网络 简述 最近对神经网络比较感兴趣，因此花了两三天时间对整个领域进行了简单的调研，梳理和学习。其中深度学习，尤其以我们熟悉的如今大火的深度网络模型,如CNN, RNN, GAN和AE及它们的子类等；是在本世纪初，硬件性能达到了一个新的高度后才能有如此巨大的发展的。事实上在21世纪之前，各种各样的神经网络模型已经被发明并应用。那时候由于硬件性能的限制，以及由通信网络不发达导致的数据量...
人工神经网络简介
网络资源是无限的
12-12 16万+
人工神经网络简介
姿态估计之CPN(Cascaded Pyramid Network)
年轻即出发，
07-01 2万+
这篇是face++2017年coco keypoint benchmark 数据集冠军的文章。主要提出了基于CPN(Cascaded PyramidNetwork)结构的人体关键点检测框架。Top-downpipeline：整体框架采用Top-down自上而下的检测策略。首先使用行人检测框架，先检测出行人候选框。然后使用本文的CPN网络对每一个检测出来的行人候选框进行人体关键点的回归，进而输出最终...
神经网络学习 之 BP神经网络
热门推荐
Mr.Phoebe的专栏
11-30 19万+
上一次我们讲了M-P模型，它实际上就是对单个神经元的一种建模，还不足以模拟人脑神经系统的功能。由这些人工神经元构建出来的网络，才能够具有学习、联想、记忆和模式识别的能力。BP网络就是一种简单的人工神经网络。 本文具体来介绍一下一种非常常见的神经网络模型——反向传播(Back Propagation)神经网络。概述BP（Back Propagation）神经网络是1986年由Rumelhart和Mc
cpn介绍
weixin_41609141的博客
04-03 1701
CPN (Color Petri Net） 即有色的Petri网，它在20世纪60年代首先由著名数学家Carl Adam Petri提出，适合于描述异步的、并发的计算机系统模型。 Petri网既有严格的数学表述方式，也有直观的图形表达方式，既有丰富的系统描述手段和系统行为分析技术，又为计算机科学提供坚实的概念基础。...
系统学习机器学习之神经网络（三）--GA神经网络与小波神经网络WNN
工作笔记
01-09 2万+
1 遗传算法 1．1 遗传算法简介： 遗传算法是一类借鉴生物界的进化规律（适者生存，优胜劣汰遗传机制）演化而来的随 机化搜索方法。它是由美国的 J.Holland 教授 1975 年首先提出，其主要特点是直接对结构对 象进行操作，不存在求导和函数连续性的限定；具有内在的隐并行性和更好的全局寻优能力； 采用概率化的寻优方法，能自动获取和指导优化的搜索空间，自适应地调整搜索方向，不需 要确定的
Android支持C++开发：融合LVQ与CPN的人工神经网络教程
在讲解神经网络技术的部分，我们提及了两种重要的神经网络模型：LVQ网络（Competitive Learning Vector Quantization）和对偶传播神经网络（Counterpropagation Network，CPN）。LVQ网络是Self-Organizing Map (SOM)...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值