人工蜂群算法 ABC

刚用LUA写了AGSO算法,效果奇差无比. 可能写错了..下面这个蜂群算法.效果很好.跳出局部最优的能力比较强!

  1 -- 人工蜂群算法 ABC
  2 
  3 
  4 -- lua 相关简易操作
  5 sin = math.sin
  6 cos = math.cos
  7 sqrt = math.sqrt
  8 pi = math.pi
  9 random = math.random
 10 exp = math.exp
 11 int = math.floor
 12 
 13 
 14 -- 获得不同的随机序列
 15 math.randomseed(os.time())
 16 
 17 
 18 -- ==============================求解函数==============================
 19 dim = 2                                 -- 解的维数
 20 domx = {                                -- 定义域
 21     { { -1, 2 }, { -1, 2 } },
 22     { {  2, 4 }, { -1, 1 } },
 23     { {  0, 4 }, {  0, 4 } },
 24 }
 25 maxfun = {                              -- 求解函数
 26     function(x) return 4 - (x[1] * sin( 4 * pi * x[1]) - x[2] * sin(4 * pi * x[2] + pi + 1)) end            ,
 27     function(x) return exp(x[1] - x[2] * x[2]) / (x[1] * x[1] - x[2]) + (x[1] - 3) ^ 2 end                  ,
 28     function(x) return 2 + (x[1] * x[1] + x[2] * x[2]) / 10 - (cos(2 * pi * x[1]) + cos(2 * pi * x[2])) end ,
 29 }
 30 funidx = 0
 31 -- ====================================================================
 32 
 33 
 34 -- ================================定义================================
 35 foodnum = 10                            -- 食物数量
 36 employednum = foodnum                   -- 雇佣兵等于食物数量, 每个雇佣兵负责更新一下食物
 37 onlookernum = foodnum                   -- 观察蜂也设置为食物数量, 理论上每个食物都有机会提高
 38 foods = {}                              -- 食物, 即可行解 还包含了,函数值,适应度,最优次数
 39 gbest = 0                               -- 当前全局最优
 40 optmaxtime = 20                         -- 局部最优最大值
 41 itermax = 100                           -- 迭代次数
 42 -- ====================================================================
 43 
 44 
 45 -- ==============================工具函数==============================
 46 -- 适应度函数, 此处全设为Y值
 47 function getfitness(y) return y end
 48 
 49 -- 食物初始化, 并选出最佳
 50 function foodinit()
 51     for i = 1, foodnum do
 52         foods[i] = {}
 53         for j = 1, dim do
 54             foods[i][j] = domx[funidx][j][1] + (domx[funidx][j][2] - domx[funidx][j][1]) * random()
 55         end
 56         foods[i].y = maxfun[funidx](foods[i])
 57         foods[i].fitness = getfitness(foods[i].y)
 58         foods[i].opttimes = 0
 59     end
 60 
 61     gbest = 1
 62     for i = 2, foodnum do
 63         if foods[i].fitness > foods[gbest].fitness then gbest = i end
 64     end
 65 end
 66 
 67 -- 单个食物重新初始化
 68 function sfoodinit(idx)
 69     for i = 1, dim do
 70         foods[idx][i] = domx[funidx][i][1] + (domx[funidx][i][2] - domx[funidx][i][1]) * random()
 71     end
 72     foods[idx].y = maxfun[funidx](foods[idx])
 73     foods[idx].fitness = getfitness(foods[idx].y)
 74     foods[idx].opttimes = 0
 75 
 76     if idx == gbest then
 77         gbest = 1
 78         for i = 2, foodnum do
 79             if foods[i].fitness > foods[gbest].fitness then gbest = i end
 80         end
 81         --print("去掉一个全局最优")
 82     else
 83         if foods[idx].fitness > foods[gbest].fitness then gbest = idx end
 84         --print("去掉一个局部最优")
 85     end
 86 end
 87 
 88 
 89 -- 更新食物
 90 function updatefood(idx)
 91     dimi = int(random() * dim) + 1
 92 
 93     idx1 = int(random() * foodnum) + 1
 94     while idx1 == idx do
 95         idx1 = int(random() * foodnum) + 1
 96     end
 97 
 98     tmpfood = {}
 99     for i = 1, dim do
100         tmpfood[i] = foods[idx][i]
101     end
102 
103     tmpfood[dimi] = tmpfood[dimi] + (foods[idx1][dimi] - tmpfood[dimi]) * (random() - 0.5) * 2
104     if tmpfood[dimi] < domx[funidx][dimi][1] then
105         tmpfood[dimi] = domx[funidx][dimi][1]
106     elseif tmpfood[dimi] > domx[funidx][dimi][2] then
107         tmpfood[dimi] = domx[funidx][dimi][2]
108     end
109 
110     tmpfood.y = maxfun[funidx](tmpfood)
111     tmpfood.fitness = getfitness(tmpfood.y)
112 
113     if tmpfood.fitness > foods[idx].fitness then
114         foods[idx].y = tmpfood.y
115         foods[idx].fitness = tmpfood.fitness
116         foods[idx].opttimes = 0
117         for i = 1, dim do foods[idx][i] = tmpfood[i] end
118 
119         if foods[idx].fitness > foods[gbest].fitness then gbest = idx end
120     else
121         foods[idx].opttimes = foods[idx].opttimes + 1
122     end
123 
124 end
125 -- ====================================================================
126 
127 
128 -- ===============================主函数===============================
129 function main(idx)
130     -- 功能选取
131     funidx = idx
132     -- 系统初始化
133     foodinit()
134 
135     -- 开始迭代
136     for iter = 1, itermax do
137         -- 雇佣蜂
138         for i = 1, employednum do
139             updatefood(i)
140         end
141 
142         -- 观察蜂, 非轮盘赌
143         fitsum = {}
144         for i = 1, foodnum do
145             fitsum[i] = ( 0.9 * ( foods[i].fitness / foods[gbest].fitness ) ) + 0.1
146         end
147 
148         cnt = 0
149         while cnt < onlookernum do
150             for i = 1, foodnum do
151                 if random() < fitsum[i] then
152                     updatefood(i)
153                     cnt = cnt + 1
154                     if cnt >= onlookernum then break end
155                 end
156             end
157         end
158 
159         -- 侦查蜂
160         maxoptidx = 1
161         for i = 2, foodnum do
162             if foods[i].opttimes > foods[maxoptidx].opttimes then maxoptidx = i end
163         end
164 
165         if foods[maxoptidx].opttimes > optmaxtime then sfoodinit(maxoptidx) end
166     end
167 end
168 -- ====================================================================
169 
170 t1 = os.clock()
171 
172 main(1)
173 print(string.format("函数值为: %.8f \t解为: (%.3f, %.3f)", foods[gbest].y, foods[gbest][1], foods[gbest][2]))
174 main(2)
175 print(string.format("函数值为: %.8f \t解为: (%.3f, %.3f)", foods[gbest].y, foods[gbest][1], foods[gbest][2]))
176 main(3)
177 print(string.format("函数值为: %.8f \t解为: (%.3f, %.3f)", foods[gbest].y, foods[gbest][1], foods[gbest][2]))
178 
179 t2 = os.clock()
180 
181 print("times: ", 1000 * (t2 - t1))

  1 /* 人工蜂群算法 ABC C语言 */
  2 #include <stdio.h>
  3 #include <stdlib.h>
  4 #include <string.h>
  5 #include <time.h>
  6 #include <math.h>
  7 #include <windows.h>
  8 
  9 #define PI         3.1415926f
 10 #define X_DIM      2
 11 #define RND        ((float)rand() / (RAND_MAX + 1))
 12 
 13 float domx[2][2] =
 14 {
 15     { -1.0f, 2.0f}, { -1.0f, 2.0f}
 16 };
 17 
 18 typedef struct tag_food
 19 {
 20     float x[X_DIM];
 21     float y;
 22     int opttimes;
 23 } food_t;
 24 
 25 const int foodnum = 30;                     /*食物数量*/
 26 const int employednum = foodnum;            /*雇佣兵等于食物数量, 每个雇佣兵负责更新一个食物*/
 27 const int onlookernum = foodnum;            /*观察蜂也设置为食物数量, 理论上每个食物都有机会提高*/
 28 food_t foods[foodnum];                      /*食物, 即可行解 还包含了,函数值,适应度,最优次数*/
 29 const int maxopttimes = 20;                 /*局部最优最大值*/
 30 const int itermax = 100;                    /*迭代次数*/
 31 
 32 int gbest;
 33 
 34 
 35 float func_y( float* x )
 36 {
 37     return 4 - ( x[0] * sin( 4 * PI * x[0] ) - x[1] * sin( 4 * PI * x[1] + PI + 1 ) );
 38 }
 39 
 40 
 41 void foods_init()
 42 {
 43     register int i, j;
 44 
 45     for ( i = 0; i < foodnum; i ++ )
 46     {
 47         for ( j = 0; j < X_DIM; j ++ )
 48         {
 49             foods[i].x[j] = domx[j][0] + ( domx[j][1] - domx[j][0] ) * RND;
 50         }
 51 
 52         foods[i].y = func_y( foods[i].x );
 53         foods[i].opttimes = 0;
 54     }
 55 
 56     gbest = 0;
 57     for ( i = 1; i < foodnum; i ++ )
 58     {
 59         if ( foods[i].y > foods[gbest].y )
 60         {
 61             gbest = i;
 62         }
 63     }
 64 }
 65 
 66 void food_init_s( int idx )
 67 {
 68     register int i;
 69 
 70     for ( i = 0; i < X_DIM; i ++ )
 71     {
 72         foods[idx].x[i] = domx[i][0] + ( domx[i][1] - domx[i][0] ) * RND;
 73     }
 74 
 75     foods[idx].y = func_y( foods[idx].x );
 76     foods[idx].opttimes = 0;
 77 
 78     if ( idx != gbest )
 79     {
 80         if ( foods[idx].y > foods[gbest].y )
 81         {
 82             gbest = idx;
 83         }
 84     }
 85     else
 86     {
 87         gbest = 0;
 88         for ( i = 1; i < foodnum; i ++ )
 89         {
 90             if ( foods[i].y > foods[gbest].y )
 91             {
 92                 gbest = i;
 93             }
 94         }
 95     }
 96 }
 97 
 98 void food_update( int idx )
 99 {
100     food_t tmpfood;
101     int idx1, dimi;
102 
103     while ( ( idx1 = ( int )( RND * foodnum ) ) == idx );
104 
105     dimi = ( int )( RND * X_DIM );
106 
107     memcpy( tmpfood.x, foods[idx].x, sizeof( foods[idx].x ) );
108 
109     tmpfood.x[dimi] += ( foods[idx1].x[dimi] - tmpfood.x[dimi] ) * ( RND - 0.5f ) * 2;
110 
111     if ( tmpfood.x[dimi] < domx[dimi][0] )
112     {
113         tmpfood.x[dimi] = domx[dimi][0];
114     }
115     else if ( tmpfood.x[dimi] > domx[dimi][1] )
116     {
117         tmpfood.x[dimi] = domx[dimi][1];
118     }
119 
120     tmpfood.y = func_y( tmpfood.x );
121 
122     if ( tmpfood.y > foods[idx].y )
123     {
124         memcpy( foods + idx, &tmpfood, sizeof( food_t ) );
125         if ( foods[idx].y > foods[gbest].y )
126         {
127             gbest = idx;
128         }
129     }
130     else
131     {
132         foods[idx].opttimes ++;
133     }
134 }
135 
136 
137 int main()
138 {
139     DWORD dwT1, dwT2;
140     int iter, cnt, optidx;
141     register int i;
142     float fit;
143 
144     srand( ( unsigned int )time( NULL ) );
145 
146 
147     dwT1 = GetTickCount();
148 
149     foods_init();
150 
151     for ( iter = 0; iter < itermax; iter ++ )
152     {
153         for ( i = 0; i < employednum; i ++ )
154         {
155             food_update( ( ( ( int )( RND * 10 ) ) * i ) % foodnum );
156         }
157 
158         cnt = 0;
159         while ( cnt < onlookernum )
160         {
161             for ( i = 0; i < foodnum; i ++ )
162             {
163                 fit = ( 0.6f * ( foods[i].y / foods[gbest].y ) ) + 0.1f;
164                 if ( RND < fit )
165                 {
166                     food_update( i );
167                     if ( ++ cnt == onlookernum )
168                     {
169                         break;
170                     }
171                 }
172             }
173         }
174 
175         optidx = 0;
176         for ( i = 1; i < foodnum; i ++ )
177         {
178             if ( foods[i].opttimes > foods[optidx].opttimes )
179             {
180                 optidx = i;
181             }
182         }
183 
184         if ( foods[optidx].opttimes > maxopttimes )
185         {
186             food_init_s( optidx );
187         }
188     }
189 
190     dwT2 = GetTickCount() - dwT1;
191 
192     fprintf( stdout, "函数值为: %.8f\t解为: (%.3f, %.3f)\t时间: %d", \
193              foods[gbest].y, foods[gbest].x[0], foods[gbest].x[1], dwT2 );
194 
195     return 0;
196 }

  1 // 人工蜂群算法 ABC
  2 
  3 // 获得不同的随机序列
  4 // math.randomseed(os.time())
  5 
  6 
  7 // ==============================求解函数==============================
  8 var dim = 2;                                // 解的维数
  9 var domx = [                                // 定义域
 10                [ [ -1, 2 ], [ -1, 2 ] ],
 11                [ [  2, 4 ], [ -1, 1 ] ],
 12                [ [  0, 4 ], [  0, 4 ] ],
 13            ];
 14 var maxfun = [                              // 求解函数
 15     function( x )
 16     {
 17         return 4 - ( x[0] * Math.sin( 4 * Math.PI * x[0] ) - x[1] * Math.sin( 4 * Math.PI * x[1] + Math.PI + 1 ) );
 18     },
 19     function( x )
 20     {
 21         return Math.exp( x[0] - x[1] * x[1] ) / ( x[0] * x[0] - x[1] ) + Math.pow( x[0] - 3, 2);
 22     },
 23     function( x )
 24     {
 25         return 2 + ( x[0] * x[0] + x[1] * x[1] ) / 10 - ( Math.cos( 2 * Math.PI * x[0] ) + Math.cos( 2 * Math.PI * x[1] ) );
 26     }
 27 ];
 28 var funidx = 0;
 29 // ====================================================================
 30 
 31 
 32 // ================================定义================================
 33 var foodnum = 10;                            // 食物数量
 34 var employednum = foodnum;                   // 雇佣兵等于食物数量, 每个雇佣兵负责更新一下食物
 35 var onlookernum = foodnum;                   // 观察蜂也设置为食物数量, 理论上每个食物都有机会提高
 36 var foods = new Object( foodnum );           // 食物, 即可行解 还包含了,函数值,适应度,最优次数
 37 var gbest = 0;                               // 当前全局最优
 38 var optmaxtime = 20;                         // 局部最优最大值
 39 var itermax = 100;                           // 迭代次数
 40 // ====================================================================
 41 
 42 
 43 // ==============================工具函数==============================
 44 // 适应度函数, 此处全设为Y值
 45 function getfitness( y )
 46 {
 47     return y;
 48 }
 49 
 50 // 食物初始化, 并选出最佳
 51 function foodinit()
 52 {
 53     var i, j;
 54 
 55     for ( i = 0; i < foodnum; i ++ )
 56     {
 57         foods[i] = {x:new Array(dim)};
 58         for ( j = 0; j < dim; j ++ )
 59         {
 60             foods[i].x[j] = domx[funidx][j][0] + ( domx[funidx][j][1] - domx[funidx][j][0] ) * Math.random();
 61         }
 62         foods[i].y = maxfun[funidx]( foods[i].x );
 63         foods[i].fitness = getfitness( foods[i].y );
 64         foods[i].opttimes = 0;
 65     }
 66 
 67     gbest = 0;
 68     for ( i = 1; i < foodnum; i ++ )
 69     {
 70         if ( foods[i].fitness > foods[gbest].fitness )
 71         {
 72             gbest = i;
 73         }
 74     }
 75 }
 76 
 77 
 78 // 单个食物重新初始化
 79 function sfoodinit( idx )
 80 {
 81     var i;
 82 
 83     for ( i = 0; i < dim; i ++ )
 84     {
 85         foods[idx].x[i] = domx[funidx][i][0] + ( domx[funidx][i][1] - domx[funidx][i][0] ) * Math.random();
 86     }
 87     foods[idx].y = maxfun[funidx]( foods[idx].x );
 88     foods[idx].fitness = getfitness( foods[idx].y );
 89     foods[idx].opttimes = 0;
 90 
 91     if ( idx == gbest )
 92     {
 93         gbest = 0;
 94         for ( i = 1; i < foodnum; i ++ )
 95         {
 96             if ( foods[i].fitness > foods[gbest].fitness )
 97             {
 98                 gbest = i;
 99             }
100         }
101     }
102     else
103     {
104         if ( foods[idx].fitness > foods[gbest].fitness )
105         {
106             gbest = idx;
107         }
108     }
109 }
110 
111 
112 
113 // 更新食物
114 function updatefood( idx )
115 {
116     var dimi, idx1;
117     var tmpfood;
118 
119     dimi = Math.floor( Math.random() * dim );
120 
121     while ( ( idx1 = Math.floor( Math.random() * foodnum ) ) == idx );
122 
123     tmpfood = new Object();
124     tmpfood.x = foods[idx].x.concat();
125 
126     tmpfood.x[dimi] = tmpfood.x[dimi] + ( foods[idx1].x[dimi] - tmpfood.x[dimi] ) * ( Math.random() - 0.5 ) * 2;
127     if ( tmpfood.x[dimi] < domx[funidx][dimi][0] )
128     {
129         tmpfood.x[dimi] = domx[funidx][dimi][0];
130     }
131     else if ( tmpfood.x[dimi] > domx[funidx][dimi][1] )
132     {
133         tmpfood.x[dimi] = domx[funidx][dimi][1];
134     }
135 
136 
137     tmpfood.y = maxfun[funidx]( tmpfood.x );
138     tmpfood.fitness = getfitness( tmpfood.y );
139     tmpfood.opttimes = 0;
140 
141     if ( tmpfood.fitness > foods[idx].fitness )
142     {
143         foods[idx] = tmpfood;
144 
145         if ( foods[idx].fitness > foods[gbest].fitness )
146         {
147             gbest = idx;
148         }
149     }
150     else
151     {
152         foods[idx].opttimes ++;
153     }
154 }
155 // ====================================================================
156 
157 
158 // ===============================主函数===============================
159 function main( idx )
160 {
161 
162     var iter;
163     var fitsum;
164     var cnt, maxoptidx;
165 
166     // 功能选取
167     funidx = idx;
168     // 系统初始化
169     foodinit();
170 
171     // 中间数组
172     fitsum = new Array();
173 
174     // 开始迭代
175     for ( iter = 0; iter < itermax; iter ++ )
176     {
177         // 雇佣蜂
178         for ( i = 0; i < employednum; i ++ )
179         {
180             updatefood( i );
181         }
182 
183         // 观察蜂, 非轮盘赌
184         for ( i = 0; i < foodnum; i ++ )
185         {
186             fitsum[i] = ( 0.9 * ( foods[i].fitness / foods[gbest].fitness ) ) + 0.1;
187         }
188 
189         cnt = 0;
190         while ( cnt < onlookernum )
191         {
192             for ( i = 0; i < foodnum; i ++ )
193             {
194                 if ( Math.random() < fitsum[i] )
195                 {
196                     updatefood( i );
197                     if ( ++ cnt >= onlookernum ) break;
198                 }
199             }
200         }
201 
202         // 侦查蜂
203         maxoptidx = 0;
204         for ( i = 1; i < foodnum; i ++ )
205         {
206             if ( foods[i].opttimes > foods[maxoptidx].opttimes )
207             {
208                 maxoptidx = i;
209             }
210         }
211 
212         if ( foods[maxoptidx].opttimes > optmaxtime )
213         {
214             sfoodinit( maxoptidx );
215         }
216     }
217 }
218 // ====================================================================
219 
220 var t1 = new Date();
221 
222 main( 0 );
223 document.write( "函数值为: ", foods[gbest].y, " \t解为: (", foods[gbest].x[0], ", ", foods[gbest].x[1], ")<br>\n");
224 main( 1 );
225 document.write( "函数值为: ", foods[gbest].y, " \t解为: (", foods[gbest].x[0], ", ", foods[gbest].x[1], ")<br>\n");
226 main( 2 );
227 document.write( "函数值为: ", foods[gbest].y, " \t解为: (", foods[gbest].x[0], ", ", foods[gbest].x[1], ")<br>\n");
228 
229 document.write( "times: ", new Date() - t1 );