# SOMO-m Optimization Algorithm with Multiple Winners

Authors: Wei Wu; Atlas Khan
Journal: Discrete Dynamics in Nature and Society
 (2012)

---

## Abstract

Self-organizing map (SOM) neural networks have been widely applied in information sciences. In particular, Su and Zhao proposes in (2009) an SOM-based optimization (SOMO) algorithm in order to find a wining neuron, through a competitive learning process, that stands for the minimum of an objective function. In this paper, we generalize the SOM-based optimization (SOMO) algorithm to so-called SOMO-m algorithm with m winning neurons. Numerical experiments show that, for m>1, SOMO-m algorithm converges faster than SOM-based optimization (SOMO) algorithm when used for finding the minimum of functions. More importantly, SOMO-m algorithm with m≥2 can be used to find two or more minimums simultaneously in a single learning iteration process, while the original SOM-based optimization (SOMO) algorithm has to fulfil the same task much less efficiently by restarting the learning iteration process twice or more times.


---

## Body

## 1. Introduction

Self-organizing map (SOM) neural networks have been widely applied in information sciences [1–7]. In particular, an SOM-based optimization (SOMO) algorithm is proposed in [8, 9] to find a winning neuron, through a competitive learning process, that stands for the minimum of an objective function. They compared the SOM-based optimization (SOMO) algorithm with genetic algorithms [10, 11] and particle swarm optimization algorithm [12–17], and they showed that the SOM-based optimization (SOMO) algorithm can locate the minimum much faster than the genetic algorithm and the particle swarm optimization algorithm.The aim of this paper is to generalize SOMO algorithm to so called SOMO-m algorithm to find m winning neurons in a single learning process. A separation technique is introduced in the learning process to prevent the accumulation of the m-wining neurons. Numerical experiments show that, for m≥2, SOMO-m algorithm converges faster than SOMO algorithm when they are used for finding the minimum of functions. A more important merit of SOMO-m algorithm with m≥2 is that it can find two or more minimums simultaneously in a single learning iteration process, while the original SOMO algorithm has to fulfil the same task much less efficiently by restarting the learning iteration process twice or more times.This paper is organized as follows. In Section2, a brief introduction of SOMO algorithm is given. Our SOMO-m algorithm is proposed in Section 3. Section 4 is devoted to some supporting numerical simulations.


## 2. Original SOM-Based Optimization (SOMO) Algorithm

Self-organizing map (SOM) is an unsupervised learning algorithm proposed by Kohonen [18–20]. The principal goal of the SOM algorithm is to map an incoming pattern in a higher dimensional space into a lower (usually one or two) dimensional space, and perform this transforation adaptively in a topological ordered fashion. The applications of SOM range widely from simulations used for the purpose of understanding and modeling of computational maps in the brain to subsystems for engineering applications such as speech recognition, vector quantization and cluster analysis [18–26].Different from the usual SOM algorithm, an SOM-Based optimization (SOMO) algorithm is introduced in Su and Zhao [8] for continuous optimization. In the following, let us describe SOMO algorithm [8] used for finding the minimum point x* of a function f(x), x∈Rn. The SOMO network contains M×N neurons arranged as a two dimensional array. For each neuron (i,j), its weight W_i,j is a vector in Rn, where 1≤i≤M and 1≤j≤N for some positive integers M and N. For a special input x_=(x1,…,xn)=(1,1,…,1)∈Rn, the winner out of all the neurons is defined as
(2.1)(i*,j*)=arg1≤i≤M,1≤j≤N⁡min⁡f((W_i,j)1×x1,…,(W_i,j)n×xn)=arg1≤i≤M,1≤j≤N⁡min⁡f((W_i,j)1×1,…,(W_i,j)n×1)=arg1≤i≤M,1≤j≤N⁡min⁡f(W_i,j).
The idea of SOM training is applied to the network such that the weight W_i*,j* of the winner will get closer and closer to the minimum point x* during the iterative training process. The detail of the training process is as follows:Step 1.
Initialization.Substep 1 (Initialization of the neurons on the four corners).
The weight vectors of the neurons on the corners are initialized as follows:(2.2)W_1,1=(l1,l2,…,ln)T,W_M,N=(h1,h2,…,hn)T,W_1,N=(l1,l2,…,l⌊n/2⌋,h⌊n/2⌋+1,…,hn)T,W_M,1=(h1,h2,…,h⌊n/2⌋,l⌊n/2⌋+1,…,ln)T.
Here, the two points (l1,l2,…,ln)T and (h1,h2,…,hn)T are randomly chosen and far enough from each other.Substep 2 (Initialization of the neurons on the four edges).
The initialization of the weights of the neurons on the four edges is as follows:(2.3)W_1,j=W_1,N-W_1,1N-1(j-1)+W_1,1=j-1N-1W_1,N+N-jN-1W_1,1,W_M,j=W_M,N-W_M,1N-1(j-1)+W_M,1=j-1N-1W_M,N+N-jN-1W_M,1,W_i,1=W_M,1-W_1,1M-1(i-1)+W_1,1=i-1M-1W_M,1+M-iM-1W_1,1,W_i,N=W_M,N-W_1,NM-1(i-1)+W_1,N=i-1M-1W_M,N+M-iM-1W_1,N,
where i=2,…,M-1 and j=2,…,N-1.Substep 3 (Initialization of the remaining neurons).
(2.4)
W
_
i
,
j
=
W
_
i
,
N
-
W
_
i
,
1
N
-
1
(
j
-
1
)
+
W
_
i
,
1
=
j
-
1
N
-
1
W
_
i
,
N
+
N
-
j
N
-
1
W
_
1
,
N
,
where i=2,…,M-1 and j=2,…,N-1.Substep 4 (Random noise).
A small amount of random noise is added for each weight so as to keep the weight vectors from being linearly dependent as follows:(2.5)W_i,j=W_i,j+t_
for 1≤i≤M and 1≤j≤N, where t_ denotes a small random noise.Step 2.
Winner finding.
(2.6)
(
i
*
,
j
*
)
=
arg
1
≤
i
≤
M
,
1
≤
j
≤
N
min
f
(
W
_
i
,
j
)Step 3.
Weights updating. The weights of the winner and its neighbors are adjusted by the following formula:
(2.7)W_i,j(t+1)=W_i,j(t)+ηβ(i*,j*,i,j)[W_i*,j*(t)-W_i,j(t)]+λ(1-β(i*,j*,i,j))p_for1≤i≤M,1≤j≤N,t=0,1,…,
where the parameters η and λ are real-valued constants which can be either constants predefined by the user or time-varying parameters which decrease gradually when time t increases. d(i*,j*,i,j) is the lateral distance between winning neuron (i*,j*) and neuron (i,j); the randomly chosen vector p_ is called the perturbation vector, and
(2.8)β(i*,j*,i,j)=1-d(i*,j*,i,j)M2+N2.Step 4.
Go to step2 until a prespecified number of generations is achieved, or some kind of termination criterion is satisfied.


## 3. SOMO-m Algorithm

In this section, let us present our SOMO-m algorithm. We divide the section into two subsections, dealing with the training algorithms for finding one minimum and two minima of a function, respectively.


### 3.1. SOMO-m Algorithm for Finding One Minimum

The SOMO-m algorithm for finding one minimum of a function f(x) is as follows:Step 1.
The initialization of SOMO-m algorithm is the same as that of SOMO algorithm.Step 2.
This step aims to findm winning neurons, denoted by (i1*,j1*), (i2*,j2*),…,(im*,jm*) with the best objective function values among the neurons as follows:
(3.1)(i1*,j1*)=arg1≤i≤M,1≤j≤N⁡min⁡f(W_i,j),(i2*,j2*)=argi∈{1,…,M}∖S1,j∈{1,…,N}∖T1min⁡f(W_i,j),⋮(im*,jm*)=argi∈{1,…,M}∖Sm,j∈{1,…,N}∖Tm⁡min⁡f(W_i,j),
where
(3.2)S1=&{i:|i-i1*|≤R1},T1={j:|j-j1*|≤R1},(3.3)S2={i:|i-i2*|≤R2},T2={j:|j-j2*|≤R2},⋮(3.4)Sm=&{i:|i-im*|≤Rm},Tm={j:|j-jr*|≤Rm},(3.5)Sm=&(S1∪⋯∪Sm),Tm=(T1∪⋯∪Tm),
and R1,R2,…,Rm are suitably chosen sizes of neighborhoods.Step 3.
The weights of the winners and its neighbors are adjusted by the following formula:(3.6)W_i,j(t+1)=W_i,j(t)+∑r=1m‍ηrβ(ir*,jr*,i,j)[W_ir*,jr*(t)-W_i,j(t)]+∑r=1m‍λr(1-β(ir*,jr*,i,j))p_1≤i≤M,1≤j≤N,
where
(3.7)β(ir*,jr*,i,j)=1-d(ir*,jr*,i,j)M2+N2.
The ηr and λr are real-valued parameters which can be constants predefined by the user or time-varying parameters, which decreases gradually with increasing time t, and p_ is a perturbation vector.Step 4.
Go to step2 until a prespecified number of generations is achieved or some kind of termination criteria is satisfied.We first remark that in the above Step2, we require the m winners to be away from each other by using the neighborhoods Sm and Tm, such that the winners can spread around rather than accumulate in one point. Secondly, we find in our numerical experiments that it is OK to choose λr and ηr as either small constants independent of time t or small variables decreasing with increasing time t. Thirdly, we find that it is better to choose η1<η2≤⋯≤ηm. The reason for this may be the following: A smaller constant η1 might help for the first winner to converge to the minimum, while the larger ηr for r>1 might help for the other winners to reach a larger searching area.


### 3.2. SOMO-2 Algorithm for Two Minima

Here we discuss SOMO-2 algorithm for finding two minima of a function simultaneously. It is an easy matter to generalize the algorithm for finding three or more minima. SOMO-2 algorithm has the same training steps as those in the last subsection with m=2 for finding one minimum, except the step of weights updating process, which is as follows:For the neurons(i,j) in the neighborhood of the first winner (i1*,j1*) satisfying p1≤i≤p2, q1≤j≤q2, where
(3.8)p1=max⁡(i1*-R1,1),p2=min⁡(i1*+R1,M),q1=max⁡(j1*-R1,1),q2=min⁡(j1*+R1,N).
The weights updating rule is
(3.9)W_i,j(t+1)=W_i,j(t)+η1β1(i1*,j1*,i,j)[W_i1*,j1*(t)-W_i,j(t)]+λ1(1-β1(i1*,j1*,i,j))p_,
where
(3.10)β1(i1*,j1*,i,j)=1-d(i1*,j1*,i,j)M2+N2.For the rest(i,j) neurons,
(3.11)W_i,j(t+1)=W_i,j(t)+η2β2(i2*,j2*,i,j)[W_i2*,j2*(t)-W_i,j(t)]+λ2(1-β2(i2*,j2*,i,j))p_,
where
(3.12)β2(i2*,j2*,i,j)=1-d(i2*,j2*,i,j)M2+N2.We see that, in the training, the second winner(i2*,j2*) does not affect the neighboring neurons of the first winner (i1*,j1*), but does affect all the other neurons. Therefore, hopefully the first winner will converges to the minimum point of the function f(x), while the second winner converges to another minimum point.


## 3.1. SOMO-m Algorithm for Finding One Minimum

The SOMO-m algorithm for finding one minimum of a function f(x) is as follows:Step 1.
The initialization of SOMO-m algorithm is the same as that of SOMO algorithm.Step 2.
This step aims to findm winning neurons, denoted by (i1*,j1*), (i2*,j2*),…,(im*,jm*) with the best objective function values among the neurons as follows:
(3.1)(i1*,j1*)=arg1≤i≤M,1≤j≤N⁡min⁡f(W_i,j),(i2*,j2*)=argi∈{1,…,M}∖S1,j∈{1,…,N}∖T1min⁡f(W_i,j),⋮(im*,jm*)=argi∈{1,…,M}∖Sm,j∈{1,…,N}∖Tm⁡min⁡f(W_i,j),
where
(3.2)S1=&{i:|i-i1*|≤R1},T1={j:|j-j1*|≤R1},(3.3)S2={i:|i-i2*|≤R2},T2={j:|j-j2*|≤R2},⋮(3.4)Sm=&{i:|i-im*|≤Rm},Tm={j:|j-jr*|≤Rm},(3.5)Sm=&(S1∪⋯∪Sm),Tm=(T1∪⋯∪Tm),
and R1,R2,…,Rm are suitably chosen sizes of neighborhoods.Step 3.
The weights of the winners and its neighbors are adjusted by the following formula:(3.6)W_i,j(t+1)=W_i,j(t)+∑r=1m‍ηrβ(ir*,jr*,i,j)[W_ir*,jr*(t)-W_i,j(t)]+∑r=1m‍λr(1-β(ir*,jr*,i,j))p_1≤i≤M,1≤j≤N,
where
(3.7)β(ir*,jr*,i,j)=1-d(ir*,jr*,i,j)M2+N2.
The ηr and λr are real-valued parameters which can be constants predefined by the user or time-varying parameters, which decreases gradually with increasing time t, and p_ is a perturbation vector.Step 4.
Go to step2 until a prespecified number of generations is achieved or some kind of termination criteria is satisfied.We first remark that in the above Step2, we require the m winners to be away from each other by using the neighborhoods Sm and Tm, such that the winners can spread around rather than accumulate in one point. Secondly, we find in our numerical experiments that it is OK to choose λr and ηr as either small constants independent of time t or small variables decreasing with increasing time t. Thirdly, we find that it is better to choose η1<η2≤⋯≤ηm. The reason for this may be the following: A smaller constant η1 might help for the first winner to converge to the minimum, while the larger ηr for r>1 might help for the other winners to reach a larger searching area.


## 3.2. SOMO-2 Algorithm for Two Minima

Here we discuss SOMO-2 algorithm for finding two minima of a function simultaneously. It is an easy matter to generalize the algorithm for finding three or more minima. SOMO-2 algorithm has the same training steps as those in the last subsection with m=2 for finding one minimum, except the step of weights updating process, which is as follows:For the neurons(i,j) in the neighborhood of the first winner (i1*,j1*) satisfying p1≤i≤p2, q1≤j≤q2, where
(3.8)p1=max⁡(i1*-R1,1),p2=min⁡(i1*+R1,M),q1=max⁡(j1*-R1,1),q2=min⁡(j1*+R1,N).
The weights updating rule is
(3.9)W_i,j(t+1)=W_i,j(t)+η1β1(i1*,j1*,i,j)[W_i1*,j1*(t)-W_i,j(t)]+λ1(1-β1(i1*,j1*,i,j))p_,
where
(3.10)β1(i1*,j1*,i,j)=1-d(i1*,j1*,i,j)M2+N2.For the rest(i,j) neurons,
(3.11)W_i,j(t+1)=W_i,j(t)+η2β2(i2*,j2*,i,j)[W_i2*,j2*(t)-W_i,j(t)]+λ2(1-β2(i2*,j2*,i,j))p_,
where
(3.12)β2(i2*,j2*,i,j)=1-d(i2*,j2*,i,j)M2+N2.We see that, in the training, the second winner(i2*,j2*) does not affect the neighboring neurons of the first winner (i1*,j1*), but does affect all the other neurons. Therefore, hopefully the first winner will converges to the minimum point of the function f(x), while the second winner converges to another minimum point.


## 4. Simulation Results

### 4.1. Objective Functions

In this subsection, we use our SOMO-m methods to minimize the following functions.(1) Step function
(4.1)f(x_)=∑i=130‍(|xi+0.5|)2.(2) Griewant function
(4.2)f(x_)=14000∑i=130‍(xi-100)2-∏i=110‍cos⁡(xi-100i)+1.(3) Giunta function
(4.3)f(x_)=∑i=130‍sin⁡(1615xi-1)+sin⁡2(1615xi-1)+150sin⁡(4(1615xi-1))+0.3.(4)  U1 function
(4.4)f=-exp⁡(-8sin⁡(πx))-exp⁡(9.85sin⁡(2πy)).(5)   U2 function
(4.5)f=exp⁡(-8sin⁡(πx)+sin⁡(πy))-exp⁡(sin⁡(2.5πx)+sin⁡(πy)).


### 4.2. Parameters of Simulation

In Table1 we present the global minima, dimensions, and the upper bound of the number of generations for optimization algorithms. Figure 1 illustrates the graphs of these five functions in two dimensional space. The neurons are arranged as a 30×30 array, namely, M=N=30. For SOMO algorithm, we set η=0.2 and λ=0.01; for SOMO-2, η1=0.2, η2=0.3,λ1=0.01, and λ2=0.001; for SOMO-3, η1=0.2,η2=0.3,η3=0.35, λ1=0.01,  λ2=0.001, and λ3=0.0005.Table 1
Parameters for five functions.
Test function
Dimensions
Initial range
Minimum
Number of generations
Step
10
-
100
≤
x
i
≤
100
0
100
Griewank
10
-
600
≤
x
i
≤
600
0
100
Giunta
30
-
10
≤
x
i
≤
10
≈
0.9
100
U
1 function
2
0
≤
x
i
≤
1
100
U
2 function
2
0
≤
x
i
≤
1
100Graphs of the five objective functions.
(a)
Step function
(b)
Griewant function
(c)
Giunta function
(d)
U
1 function
(e)
U
2 function


### 4.3. Simulations of SOMO-m Algorithm for One Minimum

In this subsection, we investigate the performance of SOMO-m algorithm for finding one minimum. For each function, each algorithm conducted 30 runs. The stop criterion for each run is that either 100 generations are iteratively generated, or before then if the difference of two successive minima in the iteration process is less than a prescribed tolerance ϵ>0. The best solutions found for each function and each run were recorded and, for instance, the mean column in Table 2 presents the average of the 30 best solutions of the 30 runs, respectively. To measure and compare the performance of SOMO-3, the mean time, that is, the average of processing time over 30 runs is recorded. Table 2 tabulates the comparison of the simulation results of SOMO, SOMO-2, and SOMO-3 algorithms. The mean column and the standard deviation (SD) column represent the mean and the standard deviation (SD) of the best solutions of 30 runs. The highlighted (bold) entries correspond to best solutions found by SOMO-3. Figure 2 shows the performances of SOMO, SOMO-2, and SOMO-3 algorithms in typical runs.Table 2
Comparison of SOMO, SOMO-2, and SOMO-3 for finding one minimum.
Test function
Algorithm
Mean
Standard deviation
Timemean (s)
TimeSD (s)
SOMO
1.6778
e
-
016
2.4504
e
-
016
1.3813
1.4008
Step
SOMO-2
1.1321
e
-
019
8.3427
e
-
020
1.0973
1.1419
SOMO-3
7.8070
e  −  020
5.7362
e
-
020
0.8743
0.8686
SOMO
5.1773
e
-
015
2.8126
e
-
016
1.7502
1.1681
Griewant
SOMO-2
2.8126
e
-
016
3.7420
e
-
016
1.1681
1.1324
SOMO-3
2.2204
e  −  017
6.14813
e
-
017
0.9849
SOMO
0.9670
1.4901
e
-
009
1.0116
1.0049
Giunta
SOMO-2
0.9670
9.2269
e
-
011
0.7087
0.7053
SOMO-3
0.9670
5.8655
e
-
012
0.6217
0.6451
SOMO
-
1.896401167771170
e
+
004
1.018269572071048
e
-
007
0.8009
0.7584
U
1 function f
SOMO-2
-
1.896401167771323
e
+
004
2.722830731013220
e
-
009
0.6168
0.6438
SOMO-3
−1.896401167771335e  +  004
2.146099170750331
e
-
011
0.4657
0.4778
SOMO
−7.36465824205229
9.781475238601051
e
-
014
2.1060
2.1278
U
2 function f
SOMO-2
−7.36465824208548
2.101813757029311
e
-
015
1.5919
1.5198
SOMO-3
-
7.36465824208548
2.394240849331165
e
-
015
0.9831
0.9525Best performance curves for SOMO, SOMO-2, and SOMO-3 algorithms, respectively.
(a)
Step function
(b)
Griewant function
(c)
Giunta function
(d)
U
1 function
(e)
U
2 functionNow, we discuss the accuracy of the algorithms. We measure the errors for each algorithm over the 30 runs as follows:(4.6)E=130∑l=130‍|x_l-x_*|,
where x_l is the approximate solution of lth run, and x_* is the real minimum of the function. Table 3 tabulates the errors of SOMO, SOMO-2, and SOMO-3 algorithms, respectively.Table 3
Error of SOMO, SOMO-2, and SOMO-3.
Test function
Algorithm
Error
SOMO
7.2868
e
-
017
Step
SOMO-2
4.0385
e
-
019
SOMO-3
5.3813
e  −020
SOMO
6.4936
e
-
017
Griewank
SOMO-2
2.2973
e
-
019
SOMO-3
6.8401
e  −020
SOMO
0.067056308053595
Giunta
SOMO-2
0.067056308053587
SOMO-3
0.067056308053585We draw the following conclusions from the simulations in this subsection for finding one minimum.(1) SOMO-3 algorithm shows the best results for all functions based on the comparisons of the means of the best objective value and the processing time.(2) As shown in Figure 2, the SOMO-3 algorithm locates the minima faster than SOMO and SOMO-2 algorithms.(3) In Table 3, the bold entries show that the error corresponding to SOMO-3 algorithm is smaller than those of SOMO and SOMO-2 algorithms.


### 4.4. Simulations of SOMO-2 Algorithm for Two Minima

In this subsection, we present the simulation results for the case of finding simultaneously two minima of a function. The best solutions found for each run after prespecified number of generations were recorded. Table4 tabulates the comparison of the simulation results. The mean column and the standard deviation column represents the mean and the standard deviation of the best solutions of 30 runs.Table 4
Comparison of SOMO-2 and the original SOMO algorithms for finding two minima.
Test function
Algorithm
Mean
Standard deviation
Time mean (s)
TimeSD (s)
SOMO
First minimum
−7.36465824205229
9.781475238601051
e
−
014
2.1060
2.1278
U
2 function
Second minimum
−5.99322845918991
0.00379247207700
2.9716
2.865
SOMO-2
First minimum
−7.36465824124180
4.047965312150572
e
-
009
1.4967
1.4237
Second minimum
−6.07080647154294
6.025651408745671
e
-
013
SOMO
First minimum
-
1.895835670663015
e
+
004
3.927781801202260
e
-
010
1.2414
1.1168
U
1 function
Second minimum
-
1.895837311768572
e
+
004
4.152186941602799
e
-
009
1.1343
1.0938
SOMO-2
First minimum
-
1.895837311745155
e
+
004
2.482103550304831
e
-
007
0.5536
0.5631
Second minimum
-
1.895837311768680
e
+
004
2.906907306783492
e
-
009Based on observation from Table4, our conclusion for finding simultaneously two minima of a function is as follows:The proposed SOMO-2 algorithm can find two minima of a function simultaneously in a single learning iteration process, while the original SOM-based optimization (SOMO) algorithm has to fulfil the same task much less efficiently by restarting the learning iteration process twice or more times.


## 4.1. Objective Functions

In this subsection, we use our SOMO-m methods to minimize the following functions.(1) Step function
(4.1)f(x_)=∑i=130‍(|xi+0.5|)2.(2) Griewant function
(4.2)f(x_)=14000∑i=130‍(xi-100)2-∏i=110‍cos⁡(xi-100i)+1.(3) Giunta function
(4.3)f(x_)=∑i=130‍sin⁡(1615xi-1)+sin⁡2(1615xi-1)+150sin⁡(4(1615xi-1))+0.3.(4)  U1 function
(4.4)f=-exp⁡(-8sin⁡(πx))-exp⁡(9.85sin⁡(2πy)).(5)   U2 function
(4.5)f=exp⁡(-8sin⁡(πx)+sin⁡(πy))-exp⁡(sin⁡(2.5πx)+sin⁡(πy)).


## 4.2. Parameters of Simulation

In Table1 we present the global minima, dimensions, and the upper bound of the number of generations for optimization algorithms. Figure 1 illustrates the graphs of these five functions in two dimensional space. The neurons are arranged as a 30×30 array, namely, M=N=30. For SOMO algorithm, we set η=0.2 and λ=0.01; for SOMO-2, η1=0.2, η2=0.3,λ1=0.01, and λ2=0.001; for SOMO-3, η1=0.2,η2=0.3,η3=0.35, λ1=0.01,  λ2=0.001, and λ3=0.0005.Table 1
Parameters for five functions.
Test function
Dimensions
Initial range
Minimum
Number of generations
Step
10
-
100
≤
x
i
≤
100
0
100
Griewank
10
-
600
≤
x
i
≤
600
0
100
Giunta
30
-
10
≤
x
i
≤
10
≈
0.9
100
U
1 function
2
0
≤
x
i
≤
1
100
U
2 function
2
0
≤
x
i
≤
1
100Graphs of the five objective functions.
(a)
Step function
(b)
Griewant function
(c)
Giunta function
(d)
U
1 function
(e)
U
2 function


## 4.3. Simulations of SOMO-m Algorithm for One Minimum

In this subsection, we investigate the performance of SOMO-m algorithm for finding one minimum. For each function, each algorithm conducted 30 runs. The stop criterion for each run is that either 100 generations are iteratively generated, or before then if the difference of two successive minima in the iteration process is less than a prescribed tolerance ϵ>0. The best solutions found for each function and each run were recorded and, for instance, the mean column in Table 2 presents the average of the 30 best solutions of the 30 runs, respectively. To measure and compare the performance of SOMO-3, the mean time, that is, the average of processing time over 30 runs is recorded. Table 2 tabulates the comparison of the simulation results of SOMO, SOMO-2, and SOMO-3 algorithms. The mean column and the standard deviation (SD) column represent the mean and the standard deviation (SD) of the best solutions of 30 runs. The highlighted (bold) entries correspond to best solutions found by SOMO-3. Figure 2 shows the performances of SOMO, SOMO-2, and SOMO-3 algorithms in typical runs.Table 2
Comparison of SOMO, SOMO-2, and SOMO-3 for finding one minimum.
Test function
Algorithm
Mean
Standard deviation
Timemean (s)
TimeSD (s)
SOMO
1.6778
e
-
016
2.4504
e
-
016
1.3813
1.4008
Step
SOMO-2
1.1321
e
-
019
8.3427
e
-
020
1.0973
1.1419
SOMO-3
7.8070
e  −  020
5.7362
e
-
020
0.8743
0.8686
SOMO
5.1773
e
-
015
2.8126
e
-
016
1.7502
1.1681
Griewant
SOMO-2
2.8126
e
-
016
3.7420
e
-
016
1.1681
1.1324
SOMO-3
2.2204
e  −  017
6.14813
e
-
017
0.9849
SOMO
0.9670
1.4901
e
-
009
1.0116
1.0049
Giunta
SOMO-2
0.9670
9.2269
e
-
011
0.7087
0.7053
SOMO-3
0.9670
5.8655
e
-
012
0.6217
0.6451
SOMO
-
1.896401167771170
e
+
004
1.018269572071048
e
-
007
0.8009
0.7584
U
1 function f
SOMO-2
-
1.896401167771323
e
+
004
2.722830731013220
e
-
009
0.6168
0.6438
SOMO-3
−1.896401167771335e  +  004
2.146099170750331
e
-
011
0.4657
0.4778
SOMO
−7.36465824205229
9.781475238601051
e
-
014
2.1060
2.1278
U
2 function f
SOMO-2
−7.36465824208548
2.101813757029311
e
-
015
1.5919
1.5198
SOMO-3
-
7.36465824208548
2.394240849331165
e
-
015
0.9831
0.9525Best performance curves for SOMO, SOMO-2, and SOMO-3 algorithms, respectively.
(a)
Step function
(b)
Griewant function
(c)
Giunta function
(d)
U
1 function
(e)
U
2 functionNow, we discuss the accuracy of the algorithms. We measure the errors for each algorithm over the 30 runs as follows:(4.6)E=130∑l=130‍|x_l-x_*|,
where x_l is the approximate solution of lth run, and x_* is the real minimum of the function. Table 3 tabulates the errors of SOMO, SOMO-2, and SOMO-3 algorithms, respectively.Table 3
Error of SOMO, SOMO-2, and SOMO-3.
Test function
Algorithm
Error
SOMO
7.2868
e
-
017
Step
SOMO-2
4.0385
e
-
019
SOMO-3
5.3813
e  −020
SOMO
6.4936
e
-
017
Griewank
SOMO-2
2.2973
e
-
019
SOMO-3
6.8401
e  −020
SOMO
0.067056308053595
Giunta
SOMO-2
0.067056308053587
SOMO-3
0.067056308053585We draw the following conclusions from the simulations in this subsection for finding one minimum.(1) SOMO-3 algorithm shows the best results for all functions based on the comparisons of the means of the best objective value and the processing time.(2) As shown in Figure 2, the SOMO-3 algorithm locates the minima faster than SOMO and SOMO-2 algorithms.(3) In Table 3, the bold entries show that the error corresponding to SOMO-3 algorithm is smaller than those of SOMO and SOMO-2 algorithms.


## 4.4. Simulations of SOMO-2 Algorithm for Two Minima

In this subsection, we present the simulation results for the case of finding simultaneously two minima of a function. The best solutions found for each run after prespecified number of generations were recorded. Table4 tabulates the comparison of the simulation results. The mean column and the standard deviation column represents the mean and the standard deviation of the best solutions of 30 runs.Table 4
Comparison of SOMO-2 and the original SOMO algorithms for finding two minima.
Test function
Algorithm
Mean
Standard deviation
Time mean (s)
TimeSD (s)
SOMO
First minimum
−7.36465824205229
9.781475238601051
e
−
014
2.1060
2.1278
U
2 function
Second minimum
−5.99322845918991
0.00379247207700
2.9716
2.865
SOMO-2
First minimum
−7.36465824124180
4.047965312150572
e
-
009
1.4967
1.4237
Second minimum
−6.07080647154294
6.025651408745671
e
-
013
SOMO
First minimum
-
1.895835670663015
e
+
004
3.927781801202260
e
-
010
1.2414
1.1168
U
1 function
Second minimum
-
1.895837311768572
e
+
004
4.152186941602799
e
-
009
1.1343
1.0938
SOMO-2
First minimum
-
1.895837311745155
e
+
004
2.482103550304831
e
-
007
0.5536
0.5631
Second minimum
-
1.895837311768680
e
+
004
2.906907306783492
e
-
009Based on observation from Table4, our conclusion for finding simultaneously two minima of a function is as follows:The proposed SOMO-2 algorithm can find two minima of a function simultaneously in a single learning iteration process, while the original SOM-based optimization (SOMO) algorithm has to fulfil the same task much less efficiently by restarting the learning iteration process twice or more times.



---

*Source: 969104-2012-08-05.xml*