经典的SOM人工神经网络例子源码

frogfish

1. /******************************************************************************
   
2. 
   
3.                       ===================
   
4.         Network:      Self-Organizing Map
   
5.                       ===================
   
6. 
   
7.         Application:  Control
   
8.                       Pole Balancing Problem
   
9. 
   
10.         Author:       Karsten Kutza
    
11.         Date:         6.6.96
    
12. 
    
13.         Reference:    T. Kohonen   
    
14.                       Self-Organized Formation
    
15.                       of Topologically Correct Feature Maps
    
16.                       Biological Cybernetics, 43, pp. 59-69, 1982
    
17. 
    
18. ******************************************************************************/
    
19. 
    
20. 
    
21. 
    
22. 
    
23. /******************************************************************************
    
24.                             D E C L A R A T I O N S
    
25. ******************************************************************************/
    
26. 
    
27. 
    
28. #include <stdlib.h>
    
29. #include <stdio.h>
    
30. #include <math.h>
    
31. 
    
32. 
    
33. typedef int           BOOL;
    
34. typedef int           INT;
    
35. typedef double        REAL;
    
36. 
    
37. #define FALSE         0
    
38. #define TRUE          1
    
39. #define NOT           !
    
40. #define AND           &&
    
41. #define OR            ||
    
42. 
    
43. #define MIN_REAL      -HUGE_VAL
    
44. #define MAX_REAL      +HUGE_VAL
    
45. #define MIN(x,y)      ((x)<(y) ? (x) : (y))
    
46. #define MAX(x,y)      ((x)>(y) ? (x) : (y))
    
47. 
    
48. #define PI            (2*asin(1))
    
49. #define sqr(x)        ((x)*(x))
    
50. 
    
51. 
    
52. typedef struct {                     /* A LAYER OF A NET:                     */
    
53.         INT           Units;         /* - number of units in this layer       */
    
54.         REAL*         Output;        /* - output of ith unit                  */
    
55.         REAL**        Weight;        /* - connection weights to ith unit      */
    
56.         REAL*         StepSize;      /* - size of search steps of ith unit    */
    
57.         REAL*         dScoreMean;    /* - mean score delta of ith unit        */
    
58. } LAYER;
    
59. 
    
60. typedef struct {                     /* A NET:                                */
    
61.         LAYER*        InputLayer;    /* - input layer                         */
    
62.         LAYER*        KohonenLayer;  /* - Kohonen layer                       */
    
63.         LAYER*        OutputLayer;   /* - output layer                        */
    
64.         INT           Winner;        /* - last winner in Kohonen layer        */
    
65.         REAL          Alpha;         /* - learning rate for Kohonen layer     */
    
66.         REAL          Alpha_;        /* - learning rate for output layer      */
    
67.         REAL          Alpha__;       /* - learning rate for step sizes        */
    
68.         REAL          Gamma;         /* - smoothing factor for score deltas   */
    
69.         REAL          Sigma;         /* - parameter for width of neighborhood */
    
70. } NET;
    
71. 
    
72. 
    
73. /******************************************************************************
    
74.         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
    
75. ******************************************************************************/
    
76. 
    
77. 
    
78. void InitializeRandoms()
    
79. {
    
80.   srand(4715);
    
81. }      
    
82. 
    
83. 
    
84. REAL RandomEqualREAL(REAL Low, REAL High)
    
85. {
    
86.   return ((REAL) rand() / RAND_MAX) * (High-Low) + Low;
    
87. }      
    
88. 
    
89. 
    
90. REAL RandomNormalREAL(REAL Mu, REAL Sigma)
    
91. {
    
92.   REAL x,fx;
    
93. 
    
94.   do {
    
95.     x = RandomEqualREAL(Mu-3*Sigma, Mu+3*Sigma);
    
96.     fx = (1 / (sqrt(2*PI)*Sigma)) * exp(-sqr(x-Mu) / (2*sqr(Sigma)));
    
97.   } while (fx < RandomEqualREAL(0, 1));
    
98.   return x;
    
99. }     

复制代码

frogfish

1. /******************************************************************************
   
2.                A P P L I C A T I O N - S P E C I F I C   C O D E
   
3. ******************************************************************************/
   
4. 
   
5. 
   
6. #define ROWS          25
   
7. #define COLS          25
   
8. 
   
9. #define N             2
   
10. #define C             (ROWS * COLS)
    
11. #define M             1
    
12. 
    
13. #define TRAIN_STEPS   10000
    
14. #define BALANCED      100
    
15. 
    
16. FILE*                 f;
    
17. 
    
18. 
    
19. void InitializeApplication(NET* Net)
    
20. {
    
21.   INT i;
    
22.    
    
23.   for (i=0; i<Net->KohonenLayer->Units; i++) {
    
24.     Net->KohonenLayer->StepSize[i] = 1;
    
25.     Net->KohonenLayer->dScoreMean[i] = 0;
    
26.   }
    
27.   f = fopen("SOM.txt", "w");
    
28. }
    
29. 
    
30. 
    
31. void WriteNet(NET* Net)
    
32. {
    
33.   INT  r,c;
    
34.   REAL x,y,z;
    
35. 
    
36.   fprintf(f, "\n\n\n");
    
37.   for (r=0; r<ROWS; r++) {
    
38.     for (c=0; c<COLS; c++) {
    
39.       x = Net->KohonenLayer->Weight[r*ROWS+c][0];
    
40.       y = Net->KohonenLayer->Weight[r*ROWS+c][1];
    
41.       z = Net->OutputLayer->Weight[0][r*ROWS+c];
    
42.       fprintf(f, "([%5.1f? %5.1f癩, %5.1fN)    ", x, y, z);
    
43.     }
    
44.     fprintf(f, "\n");
    
45.   }
    
46. }
    
47. 
    
48. 
    
49. void FinalizeApplication(NET* Net)
    
50. {
    
51.   fclose(f);
    
52. }
    
53. 
    
54. 
    
55. /******************************************************************************
    
56.                      S I M U L A T I N G   T H E   P O L E
    
57. ******************************************************************************/
    
58. 
    
59.                                      /* SIMULATION PARAMETERS FOR THE POLE:   */
    
60. #define L             1              /* - length of pole [m]                  */
    
61. #define Mc            1              /* - mass of cart [kg]                   */
    
62. #define Mp            1              /* - mass of pole [kg]                   */
    
63. #define G             9.81           /* - acceleration due to gravity [m/s瞉  */
    
64. #define T             0.1            /* - time step [s]                       */
    
65. #define STEPS         10             /* - simulation steps in one time step   */
    
66. 
    
67. 
    
68. typedef struct {                     /* STATE VARIABLES OF A POLE:            */
    
69.         REAL          x;             /* - position of cart [m]                */
    
70.         REAL          xDot;          /* - velocity of cart [m/s]              */
    
71.         REAL          w;             /* - angle of pole [癩                   */
    
72.         REAL          wDot;          /* - angular velocity of pole [?s]      */
    
73.         REAL          F;             /* - force applied to cart               */
    
74. } POLE;                              /*   during current time step [N]        */
    
75. 
    
76. 
    
77. void InitializePole(POLE* Pole)
    
78. {
    
79.   do {
    
80.     Pole->x    = 0;
    
81.     Pole->xDot = 0;
    
82.     Pole->w    = RandomEqualREAL(-30, 30);
    
83.     Pole->wDot = 0;
    
84.     Pole->F    = 0;
    
85.   } while (Pole->w == 0);
    
86. }
    
87. 
    
88. 
    
89. void SimulatePole(POLE* Pole)
    
90. {
    
91.   INT  s;
    
92.   REAL x, xDot, xDotDot;           
    
93.   REAL w, wDot, wDotDot;                  
    
94.   REAL F;                    
    
95. 
    
96.   x    = Pole->x;
    
97.   xDot = Pole->xDot;
    
98.   w    = (Pole->w    / 180) * PI;
    
99.   wDot = (Pole->wDot / 180) * PI;
    
100.   F    = Pole->F;
     
101.   for (s=0; s<STEPS; s++) {
     
102. 
     
103.     wDotDot = (G*sin(w) + cos(w) * ((-F - Mp*L*sqr(wDot)*sin(w)) / (Mc+Mp))) /
     
104.               (L * ((REAL) 4/3 - (Mp*sqr(cos(w))) / (Mc+Mp)));
     
105. 
     
106.     xDotDot = (F + Mp*L * (sqr(wDot)*sin(w) - wDotDot*cos(w))) / (Mc+Mp);
     
107. 
     
108.     x    += (T / STEPS) * xDot;
     
109.     xDot += (T / STEPS) * xDotDot;
     
110.     w    += (T / STEPS) * wDot;
     
111.     wDot += (T / STEPS) * wDotDot;
     
112.   }
     
113.   Pole->x    = x;
     
114.   Pole->xDot = xDot;
     
115.   Pole->w    = (w    / PI) * 180;
     
116.   Pole->wDot = (wDot / PI) * 180;
     
117. }
     
118. 
     
119. 
     
120. BOOL PoleStillBalanced(POLE* Pole)
     
121. {
     
122.   return (Pole->w >= -60) AND (Pole->w <= 60);
     
123. }
     
124. 
     
125. 
     
126. REAL ScoreOfPole(POLE* Pole)
     
127. {
     
128.   return -sqr(Pole->w);
     
129. }

复制代码

frogfish

1. /******************************************************************************
   
2.                           I N I T I A L I Z A T I O N
   
3. ******************************************************************************/
   
4. 
   
5. 
   
6. void GenerateNetwork(NET* Net)
   
7. {
   
8.   INT i;
   
9. 
   
10.   Net->InputLayer   = (LAYER*) malloc(sizeof(LAYER));
    
11.   Net->KohonenLayer = (LAYER*) malloc(sizeof(LAYER));
    
12.   Net->OutputLayer  = (LAYER*) malloc(sizeof(LAYER));
    
13. 
    
14.   Net->InputLayer->Units        = N;
    
15.   Net->InputLayer->Output       = (REAL*)  calloc(N, sizeof(REAL));
    
16.       
    
17.   Net->KohonenLayer->Units      = C;
    
18.   Net->KohonenLayer->Output     = (REAL*)  calloc(C, sizeof(REAL));
    
19.   Net->KohonenLayer->Weight     = (REAL**) calloc(C, sizeof(REAL*));
    
20.   Net->KohonenLayer->StepSize   = (REAL*)  calloc(C, sizeof(REAL));
    
21.   Net->KohonenLayer->dScoreMean = (REAL*)  calloc(C, sizeof(REAL));
    
22.       
    
23.   Net->OutputLayer->Units       = M;
    
24.   Net->OutputLayer->Output      = (REAL*)  calloc(M, sizeof(REAL));
    
25.   Net->OutputLayer->Weight      = (REAL**) calloc(M, sizeof(REAL*));
    
26.       
    
27.   for (i=0; i<C; i++) {
    
28.     Net->KohonenLayer->Weight[i] = (REAL*) calloc(N, sizeof(REAL));
    
29.   }
    
30.   for (i=0; i<M; i++) {
    
31.     Net->OutputLayer->Weight[i] = (REAL*) calloc(C, sizeof(REAL));
    
32.   }
    
33. }
    
34. 
    
35. 
    
36. void RandomWeights(NET* Net)
    
37. {
    
38.   INT i,j;
    
39.    
    
40.   for (i=0; i<Net->KohonenLayer->Units; i++) {
    
41.     for (j=0; j<Net->InputLayer->Units; j++) {
    
42.       Net->KohonenLayer->Weight[i][j] = RandomEqualREAL(-30, 30);
    
43.     }
    
44.   }
    
45.   for (i=0; i<Net->OutputLayer->Units; i++) {
    
46.     for (j=0; j<Net->KohonenLayer->Units; j++) {
    
47.       Net->OutputLayer->Weight[i][j] = 0;
    
48.     }
    
49.   }
    
50. }
    
51. 
    
52. 
    
53. void SetInput(NET* Net, REAL* Input)
    
54. {
    
55.   INT i;
    
56.    
    
57.   for (i=0; i<Net->InputLayer->Units; i++) {
    
58.     Net->InputLayer->Output[i] = Input[i];
    
59.   }
    
60. }
    
61. 
    
62. 
    
63. void GetOutput(NET* Net, REAL* Output)
    
64. {
    
65.   INT i;
    
66.    
    
67.   for (i=0; i<Net->OutputLayer->Units; i++) {
    
68.     Output[i] = Net->OutputLayer->Output[i];
    
69.   }
    
70. }
    
71. 
    
72. 
    
73. /******************************************************************************
    
74.                      P R O P A G A T I N G   S I G N A L S
    
75. ******************************************************************************/
    
76. 
    
77. 
    
78. void PropagateToKohonen(NET* Net)
    
79. {
    
80.   INT  i,j;
    
81.   REAL Out, Weight, Sum, MinOut;
    
82. 
    
83.   for (i=0; i<Net->KohonenLayer->Units; i++) {
    
84.     Sum = 0;
    
85.     for (j=0; j<Net->InputLayer->Units; j++) {
    
86.       Out = Net->InputLayer->Output[j];
    
87.       Weight = Net->KohonenLayer->Weight[i][j];
    
88.       Sum += sqr(Out - Weight);
    
89.     }
    
90.     Net->KohonenLayer->Output[i] = sqrt(Sum);
    
91.   }
    
92.   MinOut = MAX_REAL;
    
93.   for (i=0; i<Net->KohonenLayer->Units; i++) {
    
94.     if (Net->KohonenLayer->Output[i] < MinOut)
    
95.       MinOut = Net->KohonenLayer->Output[Net->Winner = i];
    
96.   }
    
97. }
    
98. 
    
99. 
    
100. void PropagateToOutput(NET* Net)
     
101. {
     
102.   INT i;
     
103. 
     
104.   for (i=0; i<Net->OutputLayer->Units; i++) {
     
105.     Net->OutputLayer->Output[i] = Net->OutputLayer->Weight[i][Net->Winner];
     
106.   }
     
107. }
     
108. 
     
109. 
     
110. void PropagateNet(NET* Net)
     
111. {
     
112.   PropagateToKohonen(Net);
     
113.   PropagateToOutput(Net);
     
114. }

复制代码

frogfish

1. /******************************************************************************
   
2.                         T R A I N I N G   T H E   N E T
   
3. ******************************************************************************/
   
4. 
   
5. 
   
6. REAL Neighborhood(NET* Net, INT i)
   
7. {
   
8.   INT  iRow, iCol, jRow, jCol;
   
9.   REAL Distance;
   
10. 
    
11.   iRow = i / COLS; jRow = Net->Winner / COLS;
    
12.   iCol = i % COLS; jCol = Net->Winner % COLS;
    
13. 
    
14.   Distance = sqrt(sqr(iRow-jRow) + sqr(iCol-jCol));
    
15. 
    
16.   return exp(-sqr(Distance) / (2*sqr(Net->Sigma)));
    
17. }
    
18. 
    
19. 
    
20. void TrainKohonen(NET* Net, REAL* Input)
    
21. {
    
22.   INT  i,j;
    
23.   REAL Out, Weight, Lambda, StepSize;
    
24. 
    
25.   for (i=0; i<Net->KohonenLayer->Units; i++) {
    
26.     for (j=0; j<Net->InputLayer->Units; j++) {
    
27.       Out = Input[j];
    
28.       Weight = Net->KohonenLayer->Weight[i][j];
    
29.       Lambda = Neighborhood(Net, i);
    
30.       Net->KohonenLayer->Weight[i][j] += Net->Alpha * Lambda * (Out - Weight);
    
31.     }
    
32.     StepSize = Net->KohonenLayer->StepSize[i];
    
33.     Net->KohonenLayer->StepSize[i] += Net->Alpha__ * Lambda * -StepSize;
    
34.   }
    
35. }
    
36. 
    
37. 
    
38. void TrainOutput(NET* Net, REAL* Output)
    
39. {
    
40.   INT  i,j;
    
41.   REAL Out, Weight, Lambda;
    
42. 
    
43.   for (i=0; i<Net->OutputLayer->Units; i++) {
    
44.     for (j=0; j<Net->KohonenLayer->Units; j++) {
    
45.       Out = Output[i];
    
46.       Weight = Net->OutputLayer->Weight[i][j];
    
47.       Lambda = Neighborhood(Net, j);
    
48.       Net->OutputLayer->Weight[i][j] += Net->Alpha_ * Lambda * (Out - Weight);
    
49.     }
    
50.   }
    
51. }
    
52. 
    
53. 
    
54. void TrainUnits(NET* Net, REAL* Input, REAL* Output)
    
55. {
    
56.   TrainKohonen(Net, Input);
    
57.   TrainOutput(Net, Output);
    
58. }
    
59. 
    
60. 
    
61. void TrainNet(NET* Net)
    
62. {
    
63.   INT  n,t;
    
64.   POLE Pole;
    
65.   REAL wOld, wNew, ScoreOld, ScoreNew, dScore, dScoreMean, StepSize;
    
66.   REAL Input[N];
    
67.   REAL Output[M];
    
68.   REAL Target[M];
    
69. 
    
70.   n = 0;
    
71.   while (n<TRAIN_STEPS) {
    
72.     t = 0;
    
73.     InitializePole(&Pole);
    
74.     fprintf(f, " Time     Angle     Force\n");
    
75.     fprintf(f, "%4.1fs    %5.1f?   %5.1fN\n", t * T, Pole.w, Pole.F);
    
76.     wOld = Pole.w;
    
77.     ScoreOld = ScoreOfPole(&Pole);
    
78.     SimulatePole(&Pole);
    
79.     wNew = Pole.w;
    
80.     ScoreNew = ScoreOfPole(&Pole);
    
81.     while (PoleStillBalanced(&Pole) AND (t<BALANCED)) {
    
82.       n++;
    
83.       t++;
    
84.       Net->Alpha   = 0.5 * pow(0.01, (REAL) n / TRAIN_STEPS);
    
85.       Net->Alpha_  = 0.5 * pow(0.01, (REAL) n / TRAIN_STEPS);
    
86.       Net->Alpha__ = 0.005;
    
87.       Net->Gamma   = 0.05;
    
88.       Net->Sigma   = 6.0 * pow(0.2, (REAL) n / TRAIN_STEPS);
    
89.       Input[0] = wOld;
    
90.       Input[1] = wNew;
    
91.       SetInput(Net, Input);
    
92.       PropagateNet(Net);
    
93.       GetOutput(Net, Output);
    
94.       Pole.F = Output[0];
    
95.       StepSize = Net->KohonenLayer->StepSize[Net->Winner];
    
96.       Pole.F += StepSize * RandomNormalREAL(0, 10);
    
97.       fprintf(f, "%4.1fs    %5.1f?   %5.1fN\n", t * T, Pole.w, Pole.F);
    
98.       wOld = Pole.w;
    
99.       ScoreOld = ScoreOfPole(&Pole);
    
100.       SimulatePole(&Pole);
     
101.       wNew = Pole.w;
     
102.       ScoreNew = ScoreOfPole(&Pole);
     
103.       dScore = ScoreNew - ScoreOld;
     
104.       dScoreMean = Net->KohonenLayer->dScoreMean[Net->Winner];
     
105.       if (dScore > dScoreMean) {
     
106.         Target[0] = Pole.F;
     
107.         TrainUnits(Net, Input, Target);
     
108.       }
     
109.       Net->KohonenLayer->dScoreMean[Net->Winner] += Net->Gamma * (dScore - dScoreMean);
     
110.     }
     
111.     if (PoleStillBalanced(&Pole))
     
112.       fprintf(f, "Pole still balanced after %0.1fs ...\n\n", t * T);
     
113.     else
     
114.       fprintf(f, "Pole fallen after %0.1fs ...\n\n", (t+1) * T);
     
115.   }
     
116. }
     
117. 
     
118. 
     
119. /******************************************************************************
     
120.                                     M A I N
     
121. ******************************************************************************/
     
122. 
     
123. 
     
124. void main()
     
125. {
     
126.   NET Net;
     
127. 
     
128.   InitializeRandoms();
     
129.   GenerateNetwork(&Net);
     
130.   RandomWeights(&Net);
     
131.   InitializeApplication(&Net);
     
132.   TrainNet(&Net);
     
133.   WriteNet(&Net);
     
134.   FinalizeApplication(&Net);
     
135. }

复制代码

mengyuan0909

:lol :lol :lol :lol :lol :lol :lol :lol :lol :lol

jidiangaopei

还没有学过SOM，只是学过BP。