# Automatic Circle Detection on Images Based on an Evolutionary Algorithm That Reduces the Number of Function Evaluations

Authors: Erik Cuevas; Eduardo L. Santuario; Daniel Zaldívar; Marco Perez-Cisneros
Journal: Mathematical Problems in Engineering
 (2013)

---

## Abstract

This paper presents an algorithm for the automatic detection of circular shapes from complicated and noisy images with no consideration
of the conventional Hough transform principles. The proposed algorithm is based on a newly developed evolutionary algorithm called the Adaptive
Population with Reduced Evaluations (APRE). Our proposed algorithm reduces the number of function evaluations through the use of two mechanisms:
(1) adapting dynamically the size of the population and (2) incorporating a fitness calculation strategy, which decides whether the calculation or estimation
of the new generated individuals is feasible. As a result, the approach can substantially reduce the number of function evaluations, yet preserving the good
search capabilities of an evolutionary approach. Experimental results over several synthetic and natural images, with a varying range of complexity, validate
the efficiency of the proposed technique with regard to accuracy, speed, and robustness.


---

## Body

## 1. Introduction

The problem of detecting circular features holds paramount importance in several engineering applications such as automatic inspection of manufactured products and components, aided vectorization of drawings, and target detection [1, 2]. Circle detection in digital images has been commonly solved through the Circular Hough Transform (CHT) [3]. Unfortunately, this approach requires a large storage space that augments the computational complexity and yields a low processing speed. In order to overcome this problem, several approaches which modify the original CHT have been proposed. One well-known example is the Randomized Hough Transform (RHT) [4].As an alternative to Hough Transform-based techniques, the problem of shape recognition has also been handled through evolutionary methods. In general, they have demonstrated to deliver better results than those based on the HT considering accuracy and robustness [5]. Evolutionary methods approach the detection task as an optimization problem whose solution involves the computational expensive evaluation of objective functions. Such fact strongly restricts their use in several image processing applications; despite this, EA methods have produced several robust circle detectors which use different evolutionary algorithms like Genetic algorithms (GA) [5], Harmony Search (HSA) [6], Electromagnetism-Like (EMO) [7], Differential Evolution (DE) [8], and Bacterial Foraging Optimization (BFOA) [9].However, one particular difficulty in applying any EA to real-world problems, such as image processing, is its demand for a large number of fitness evaluations before reaching a satisfactory result. Fitness evaluations are not always straightforward as either an explicit fitness function does not exist or the fitness evaluation is computationally expensive.The problem of excessively long fitness function calculations has already been faced in the field of evolutionary algorithms (EA) and is better known as evolution control or as fitness estimation [10]. For such an approach, the idea is to replace the costly objective function evaluation for some individuals by alternative models which are based on an approximate model of the fitness landscape. The individuals to be evaluated and those to be estimated are determined following some fixed criteria which depend on the specific properties of the approximate model [11]. The models involved at the estimation can be dynamically built during the actual EA execution, since EA repeatedly sample the search space at different points [12]. There are several alternative models which have been used in combination with popular EAs. Some examples include polynomial functions [13], kriging schemas [14], multilayer perceptrons [15], and radial basis-function networks [16]. In the practice, the construction of successful models which can globally deal with the high dimensionality, ill distribution, and limited number of training samples is very difficult. Experimental studies [17] have demonstrated that if an alternative model is used for fitness evaluation, it is very likely that the evolutionary algorithm will converge to a false optimum. A false optimum is an optimum of the alternative model, which does not coincide with the optimum of the original fitness function. Under such conditions, the use of the alternative fitness models degrade the search effectiveness of the original EAs, producing frequently inaccurate solutions [18].In an EA, the population size has a direct influence on the solution quality and its computational cost [19]. Traditionally, population size is set in advance to a prespecified value and remains fixed through the entire execution of the algorithm. If the population size is too small, then the EA may converge too quickly affecting severely the solution quality [20]. On the other hand, if it is too large, then the EA may present a prohibitive computational cost [19]. Therefore, an appropriate population size allows maintaining a trade-off between computational cost and effectiveness of the algorithm. In order to solve such a problem, several approaches have been proposed for dynamically adapting the population size. These methods are grouped into three categories [21]: (i) methods that increment or decrement the number of individuals according to a fixed function; (ii) methods in which the number of individuals is modified according to the performance of the average fitness value, and (iii) algorithms based on the population diversity.In order to use either a fitness estimation strategy or an adaptive population size approach, it is necessary but not sufficient to tackle the problem of reducing the number of function evaluations. Using a fitness estimation strategy, during the evolution process with no adaptation of the population size to improve the population diversity, makes the algorithm defenseless against the convergence to a false minimum and may result in poor exploratory characteristics of the algorithm [18]. On the other hand, the adaptation of the population size omitting the fitness estimation strategy leads to increase in the computational cost [20]. Therefore, it does seem reasonable to incorporate both approaches into a single algorithm.Since most of the EAs have been primarily designed to completely evaluate all involved individuals, techniques for reducing the evaluation number are usually incorporated into the original EAs in order to estimate fitness values or to reduce the number of individuals being evaluated [22]. However, the use of alternative fitness models degrades the search effectiveness of the original EAs, producing frequently inaccurate solutions [23].This paper presents an algorithm for the automatic detection of circular shapes from complicated and noisy images without considering the conventional Hough transform principles. The proposed algorithm is based on a newly developed evolutionary algorithm called the Adaptive Population with Reduced Evaluations (APRE). The proposed algorithm reduces the number of function evaluations through the use of two mechanisms: (1) adapting dynamically the size of the population and (2) incorporating a fitness calculation strategy which decides when it is feasible to calculate or only to estimate new generated individuals.The APRE method begins with an initial population which is to be considered as a memory during the evolution process. To each memory element, a normalized fitness value, called quality factor is assigned to indicate the solution capacity that is provided by the element. Only a variable subset of memory elements is considered to be evolved. Like all EA-based methods, the proposed algorithm generates new individuals considering two operators: exploration and exploitation. Both operations are applied to improve the quality of the solutions by: (1) searching through the unexplored solution space to identify promising areas that contain better solutions than those found so far and (2) successive refinement of the best found solutions. Once the new individuals are generated, the memory is accordingly updated. At such stage, the new individuals compete against the memory elements to build the final memory configuration. In order to save computational time, the approach incorporates a fitness estimation strategy that decides which individuals can be estimated or actually evaluated. The proposed fitness calculation strategy estimates the fitness value of new individuals using memory elements located in neighboring positions which have been visited during the evolution process. In the strategy, new individuals, that are located near the memory element whose quality factor is high, have a great probability to be evaluated by using the true objective function. Similarly, evaluated those new particles lying in regions of the search space with no previous evaluations are also evaluated. The remaining search positions are only estimated by assigning the same fitness value that is the nearest location element on the memory. The use of such a fitness estimation method contributes to saving computational time, since the fitness value of only very few individuals is actually evaluated whereas the rest is just estimated.Different to other approaches that use an already existent EA as framework, the APRE method has been completely designed to substantially reduce the computational cost, yet preserving good search effectiveness.In order to detect circular shapes, the detector is implemented by encoding three pixels as candidate circles over the edge image. An objective function evaluates if such candidate circles are actually present in the edge image. Guided by the values of this objective function, the set of encoded candidate circles are evolved using the operators defined by APRE so that they can fit into the actual circles on the edge map of the image. Comparisons to several state-of-the-art evolutionary-based methods and the Randomized Hough Transform (RHT) approach on multiple images demonstrate a better performance of the proposed method in terms of accuracy, speed, and robustness.The paper is organized as follows. In Section2, the APRE algorithm and its characteristics are both described. Section 3 formulates the implementation of the circle detector. Section 4 shows the experimental results of applying our method to the recognition of circles in different image conditions. Finally, Section 5 discusses several conclusions.


## 2. The Adaptive Population with Reduced Evaluations (APRE) Algorithm

In the proposed algorithm, a population of candidate solutions to an optimization problem is evolved toward better solutions. The algorithm begins with an initial population which will be used as a memory during the evolution process. To each memory element, it is assigned a normalized fitness value called quality factor that indicates the solution capacity provided by the element.As a search strategy, the proposed algorithm implements two operations: “exploration” and “exploitation.” Both necessary in all EAs [24]. Exploration is the operation of visiting entirely new points of a search space, whilst exploitation is the process of refining those points of a search space within the neighborhood of previously visited locations in order to improve their solution quality. Pure exploration degrades the precision of the evolutionary process but increases its capacity to find new potential solutions [25]. On the other hand, pure exploitation allows refining existent solutions but adversely drives the process to fall in local optimal solutions [26]. Therefore, the ability of an EA to find a global optimal solution depends on its capacity to find a good trade-off between the exploitation of so far found elements and the exploration of the search space.The APRE algorithm is an iterative process in which several actions are executed. First, the number of memory elements to be evolved is computed. Such number is automatically modified at each iteration. Then, a set of new individuals is generated as a consequence of the execution of the exploration operation. For each new individual, its fitness value is estimated or evaluated according to a decision taken by a fitness estimation strategy. Afterwards, the memory is updated. In this stage, the new individuals produced by the exploration operation compete against the memory elements to build the final memory configuration. Finally, a sample of the best elements contained in the final memory configuration is undergone to the exploitation operation. Thus, the complete process can be divided in six phases: initialization, selecting the population to be evolved, exploration, fitness estimation strategy, memory updating, and exploitation.


### 2.1. Initialization

Like in EA, the APRE algorithm is an iterative method whose first step is to randomly initialize the populationM(k) which will be used as a memory during the evolution process. The algorithm begins by initializing (k=0) a set of Np elements (M(k)={m1,m2,…,mNp}). Each element mi is an n-dimensional vector containing the parameter values to be optimized. Such values are randomly and uniformly distributed between the prespecified lower initial parameter bound pjlow and the upper initial parameter bound pjhigh, just as it described by the following expression:
(1)mi,j=pjlow+rand(0,1)·(pjhigh-pjlow),forj=1,2,…,n,i=1,2,…,Np,
where j and i are the parameter and element indexes, respectively. Hence, mi,j is the jth parameter of the ith element.Each elementmi has two associated characteristics: a fitness value J(mi) and a quality factor Q(mi). The fitness value J(mi) assigned to each element mi can be calculated by using the true objective function f(mi) or only estimated by using the proposed fitness strategy F(mi). In addition to the fitness value, it is also assigned to mi, a normalized fitness value called quality factor Q(mi) (Q(·)∈[0,1]), which is computed as follows:
(2)Q(mi)=J(mi)-worstMbestM-worstM,
where J(mi) is the fitness value obtained by evaluation f(·) or by estimation F(·) of the memory element mi. The values worstM and bestM are defined as follows (considering a maximization problem):
(3)bestM=maxk∈{1,2,…,Np}(J(mk)),worstM=mink∈{1,2,…,Np}(J(mk)).
Since the mechanism by which an EA accumulates information regarding the objective function is an exact evaluation of the quality of each potential solution, initially, all the elements of M(k) are evaluated without considering the fitness estimation strategy proposed in this paper. This fact is only allowed at this initial stage.


### 2.2. Selecting the Population to Be Evolved

At eachk iteration, it must be selected which and how many elements from M(k) will be considered to build the population Pk in order to be evolved. Such selected elements will be undergone by the exploration and exploitation operators in order to generate a set of new individuals. Therefore, two things need to be defined: the number of elements Nek to be selected and the strategy of selection.


#### 2.2.1. The Number of ElementsNek to Be Selected

One of the mechanisms used by the APRE algorithm for reducing the number of function evaluations is to modify dynamically the size of the population to be evolved. The idea is to operate with the minimal number of individuals that guarantee the correct efficiency of the algorithm. Hence, the method aims to vary the population size in an adaptive way during the execution of each iteration. At the beginning of the process, a predetermined numberNe0 of elements are considered to build the first population; then, it will be incremented or decremented depending on the algorithm’s performance. The adaptation mechanism is based on the lifetime of the individuals and on their solution quality.In order to compute the lifetime of each individual, it is assigned a counterci (i∈(1,2,3,…,Np)) to each element mi of M(k). When the initial population M(k) is created, all the counters are set to zero. Since the memory M(k) is updated at each generation, some elements prevail and others will be substituted by new individuals. Therefore, the counter of the surviving elements is incremented by one whereas the counter of new added elements is set to zero.Another important requirement to calculate the number of elements to be evolved is the solution quality provided by each individual. The idea is to identify two classes of elements, those that provide good solutions and those that can be considered as bad solutions. In order to classify each element, the average fitness valueJA produced by all the elements of M(k) is calculated as
(4)JA=1Np∑i=1NpJ(mi),
where J(·) represents the fitness value corresponding to mi. These values are evaluated either by the true objective function f(mi) or by the fitness estimation strategy F(mi). Considering the average fitness value, two groups are built: the set G constituted by the elements of M(k) whose fitness values are greater than JA and the set B which groups the elements of M(k) whose fitness values are equal or lower than JA.Therefore, the number of individuals of the current population that will be incremented or decremented at each generation is calculated by the following model:(5)A=floor(|G|·∑l∈Gcl-|B|·∑q∈Bcqs),
where the floor (·) function maps a real number to the previous integer. |G| and |B| represent the number of elements of G and B, respectively, whereas ∑l∈Gcl and ∑q∈Bcq indicate the sum of the counters that correspond to the elements of G and B, respectively. The factor s is a term used for fine tuning. A small value of s implies a better algorithm’s performance at the price of an increment in the computational cost. On the other hand, a big value of s involves a low computational cost at the price of a decrement in the performance algorithm. Therefore, the s value must reflex a compromise between performance and computational cost. In our experiments such compromise has been found with s=10.Therefore, the number the elements that define the population to be evolved is computed according to the following model:(6)Nek=Nek-1+A.
Since the value of A can be positive or negative, the size of the population Pk may be higher or lesser than Pk-1. The computational procedure that implements this method is presented in Algorithm 1, in form of pseudocode.Algorithm 1:Selection of the number of individuals Nek to be evolved.
(1)Input:Current population M(k), counters c1,…,cNp,
the past number of individualsNek-1 and the constant factor s.
(2)JA←(1/Np)∑i=1NpJ(mi)
(3)G← FindIndividualsOverJA(M(k),JA)
(4)B← FindIndividualsUnderJA(M(k),JA)
(5)cl← FindCountersOfG(G) (Where l∈G)
(6)cq← FindCountersOfB(B) (Where q∈B)
(7)A←floor((|G|·∑l∈Gcl-|B|·∑q∈Bcq)/s)
(8)Nek←Nek-1+A
(9)Output:The number Nek


#### 2.2.2. Selection Strategy for BuildingPk

Once the number of individuals has been defined, the next step is the selection ofNek elements from M(k) for building Pk. A new population MO which contains the same elements that M(k) is generated but sorted according to their fitness values. Thus, MO presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, MO is divided in two parts: X and Y. The section X corresponds to the first Nek elements of MO whereas the rest of the elements constitute the part Y. Figure 1 shows this process.Figure 1
Necessary postprocessing implemented by the selection strategy.In order to promote diversity, in the selection strategy, the 80% of theNek individuals of Pk are taken from the first elements of X and named as Fe as shown in Figure 2, where Fe=floor (0.8*Nek). The remaining 20% of the individuals are randomly selected from section Y. Hence, the last set of Se elements (where Se=Nek-Fe) is chosen considering that all elements of Y have the same possibility of being selected. Figure 2 shows a description of the selection strategy. The computational procedure that implements this method is presented in Algorithm 2, in form of pseudocode.Algorithm 2:Selection strategy for building Pk.
(1)Input:Current population M(k) and the number of individuals Nek.
(2)MO← SortElementsFitness(M(k))
(3)[X,Y]← DivideMO(MO,Nek)
(4)Fe← floor(0.8*Nek)
(5)Se←Nek-Fe
(6)(p1k,…,pFek)← SelectElementsOfX(X,Fe)
(7)(pFe+1k,…,pFe+Sek)← SelectRandomElementsOfY(Y,Se)
(8)Output:Population Pk to be evolveFigure 2
Employed selection strategy to build the populationPk, where d,g∈Y.


### 2.3. Exploration Operation

The first main operation applied to the populationPk is the exploration operation. Considering Pk as the input population, APRE mutates Pk to produce a temporal population Tk of Nek vectors. In the exploration operation two different mutation models are used: the mutation employed by the Differential Evolution algorithm (DE) [27] and the trigonometric mutation operator [28].


#### 2.3.1. DE Mutation Operator

In this mutation, three distinct individualsr1, r2, and r3 are randomly selected from the current population Pk. Then, a new value hi,j considering the following model is created:
(7)hi,j=pr1,j+F(pr2,j-pr3,j),
where r1, r2, and r3 are randomly selected individuals such that they satisfy r1≠r2≠r3≠i, i=1 to Nek (population size), and j=1 to n (number of decision variable). Hence, pi,j is the jth parameter of the ith individual of Pk. The scale factor, F(0,1+), is a positive real number that controls the rate at which the population evolves.


#### 2.3.2. Trigonometric Mutation Operator

The trigonometric mutation operation is performed according to the following formulation:(8)hi,j=pAv(j)+F1(pr1,j-pr2,j)+F2(pr2,j-pr3,j)+F3(pr3,j-pr1,j),pAv(j)=pr1,j+pr2,j+pr3,j3,F1=(dr2-dr1),F2=(dr3-dr2),F3=(dr1-dr3),dr1=|J(pr1)|dT,dr2=|J(pr2)|dT,dr3=|J(pr3)|dT,dT=|J(pr1)|+|J(pr2)|+|J(pr3)|,
where pr1, pr2, and pr3 represent the individuals r1, r2, and r3 randomly selected from the current population Pk whereas J(·) represents the fitness value (calculated or estimated) corresponding to pi. Under this formulation, the individual pAv(j) to be perturbed is the average value of three randomly selected vectors (r1, r2, and r3). The perturbation to be imposed over such individual is implemented by the sum of three weighted vector differentials. F1, F2, and F3 are the weights applied to these vector differentials. Notice that the trigonometric mutation is a greedy operator since it biases the pAv(j) strongly in the direction where the best one of three individuals is lying.Computational Procedure. Considering Pk as the input population, all its Nek individuals are sequentially processed in cycles beginning by the first individual p1. Therefore, in the cycle i (where it is processed the individual i), three distinct individuals r1, r2, and r3 are randomly selected from the current population considering that they satisfy the following conditions r1≠r2≠r3≠i. Then, it is processed each dimension of pi beginning by the first parameter 1 until the last dimension n has been reached. At each processing cycle, the parameter pi,j considered as a parent, creates an offspring ti,j in two steps. In the first step, from the selected individuals r1, r2, and r3, a donor vector hi,j is created by means of two different mutation models. In order to select which mutation model is applied, a uniform random number is generated within the range [0,1]. If such number is less than a threshold MR, the donor vector hi,j is generated by the DE mutation operator; otherwise, it is produced by the trigonometric mutation operator. Such process can be modeled as follows:
(9)hi,j={Byusing(7)withprobabilityMRByusing(8)withprobability(1-MR).
In the second step, the final value of the offspring ti,j is determined. Such decision is stochastic; hence, a second uniform random number is generated within the range [0,1]. If this random number is less than CH, ti,j=hi,j; otherwise, ti,j=pi,j. This operation can be formulated as follows:
(10)ti,j={hi,jwithprobabilityCHpi,jwithprobability(1-CH).
The complete computational procedure is presented in Algorithm 3, in form of pseudocode.Algorithm 3:Exploration operation of APRE algorithm.
(1)  Input:Current population Pk
(2)fori=1 to Nek do
(3)  (pr1,pr2,pr3)← SelectElements()  % Considering that r1≠r2≠r3≠i
(4)for j=1 to n  do
(5)if (rand(0,1)<=MR) then
(6)hi,j← DEMutation(pr1,pr2,pr3) % (7)
(7)else
(8)hi,j← TrigonometricMutation(pr1,pr2,pr3) % (8)
(9)end if
(10)if(rand(0,1)<=CH) then
(11)ti,j←hi,j
(12)else
(13) ti,j←pi,j
(14)end if
(15)end for
(16)end for
(17)Output:Population Tk


### 2.4. Fitness Estimation Strategy

Once the populationTk has been generated by the exploration operation, it is necessary to calculate the fitness value provided by each individual. In order to reduce the number of function evaluations, a fitness estimation strategy that decides which individuals can be estimated or actually evaluated is introduced. The idea of such a strategy is to find the global optimum of a given function considering only very few number of function evaluations.In this paper, we explore a local approximation scheme that estimates the fitness values based on previously evaluated neighboring individuals, stored in the memoryM(k) during the evolution process. The strategy decides if an individual ti is calculated or estimated based on two criteria. The first one considers the distance between ti and the nearest element mne contained in M(k) (where mn∈(m1,m2,…,mNp)) whereas the second one examines the quality factor provided by the nearest element mne(Q(mne)).In the model, individuals ofTk that are near the elements of M(k) holding the best quality values have a high probability to be evaluated. Such individuals are important, since they will have a stronger influence on the evolution process than other individuals. In contrast, individuals of Tk that are also near the elements of M(k) but with a bad quality value maintain a very low probability to be evaluated. Thus, most of such individuals will only be estimated, assigning it the same fitness value that the nearest element of M(k). On the other hand, those individuals in regions of the search space with few previous evaluations (individuals of Tk located farther than a distance D) are also evaluated. The fitness values of these individuals are uncertain since there is no close reference (close points contained in M(k)).Therefore, the fitness estimation strategy follows two rules in order to evaluate or estimate the fitness values.(1)
If the new individualti is located closer than a distance D with respect to the nearest element mne stored in M, then a uniform random number is generated within the range [0,1]. If such number is less than Q(mne), ti is evaluated by the true objective function (f(ti)). Otherwise, its fitness value is estimated assigning it the same fitness value that mne (F(ti)=J(mne)). Figures 3(a) and 3(b) draw the rule procedure.(2)
If the new individualti is located longer than a distance D with respect to the nearest individual location mne stored in M, then the fitness value of ti is evaluated using the true objective function (f(ti)). Figure 3(c) outlines the rule procedure.The fitness estimation strategy. (a) According to the rule  1, the individualti has a high probability to be evaluated f(t1), since it is located closer than a distance D with respect to the nearest element mne=m1 whose quality factor Q(m1) corresponds to the best value. (b) According to the rule  1, the individual ti has a high probability to be estimated F(t1) (assigning it the same fitness value as mne (F(ti)=J(m3))), since it is located closer than a distance D with respect to the nearest element mne=m3 whose quality factor Q(m3) corresponds to the worst value. (c) According to the rule  2, the individual ti is evaluated, as there is no close reference in its neighborhood.
(a)
(b)
(c)From the rules, the distanceD controls the trade off between the evaluation and estimation of new individuals. Unsuitable values of D result in a lower convergence rate, longer computation time, larger function evaluation number, convergence to a local maximum, or unreliability of solutions. Therefore, the D value is computed considering the following equation:
(11)D=∑j=1n(pjhigh-pjlow)50·n,
where pjlow and pjhigh represent the prespecified lower bound and the upper bound of the j-parameter, respectively, within an n-dimensional space. Both rules show that the fitness estimation strategy is simple and straightforward. Figure 3 illustrates the procedure of fitness computation for a new candidate solution ti considering the two different rules. In the problem the objective function f is maximized with respect to two parameters (x1,x2). In all figures (Figures 3(a), 3(b), and 3(c)) the memory M(k) contains five different elements (m1,m2,m3,m4,  and m5) with their corresponding fitness values (J(m1),J(m2),J(m3),J(m4), and J(m5)) and quality factors (Q(m1),Q(m2),Q(m3),Q(m4), and Q(m5)). Figures 3(a) and 3(b) show the fitness evaluation (f(x1,x2)) or estimation (F(x1,x2)) of the new individual ti following the rule  1. Figure 3(a) represents the case when mne holds a good quality factor whereas Figure 3(b) when mne maintains a bad quality factor. Finally, Figure 3(c) presents the fitness evaluation of ti considering the conditions of rule  2. The procedure that implements the fitness estimation strategy is presented in Algorithm 4, in form of pseudocode.Algorithm 4:Fitness estimation strategy.
(1)  Input:Population Tk and memory M(k)
(2)fori=1 to Nek do
(3)  mne← FindNearestElementOfM(ti)
(4)distance← FindTheDistance(ti,mne)
(5)if (distance < D) then
(6)if (rand(0, 1) <= Q(mne)) then
(7)J(ti)←f(ti) % Evaluation
(8)  else              (Rule  1)
(9)J(ti)←J(mne) % Estimation
(10)end if
(11)  else
(12)J(ti)←f(ti)   % Evaluation  (Rule  2)
(13)end if
(14)end for
(15)Output:fitness values of  Tk


### 2.5. Memory Updating

Once the operations of exploration and fitness estimation have been applied, it is necessary to update the memoryM(k). In the APRE algorithm, the memory M(k) is updated considering the following procedure.(1)
The elements ofM(k) and Tk are merged into MU (MU=M(k)∪Tk).(2)
From the resulting elements ofMU, it is selected the Np best elements according to their fitness values to build the new memory M(k+1).(3)
The countersc1,c2,…,cNp must be updated. Thus, the counter of the surviving elements is incremented by 1 whereas the counter of modified elements is set to zero.


### 2.6. Exploitation Operation

The second main operation applied by the APRE algorithm is the exploitation operation. Exploitation, in the context of EA, is the process of refining the solution quality of existent promising solutions within a small neighborhood. In order to implement such a process, a new memoryME is generated, which contains the same elements that M(k+1) but sorted according to their fitness values. Thus, ME presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, the 10% of the Np (Ne) individuals are taken from the first elements of ME to build the set E (E={me1,me2,…,meNe}, where Ne=ceil(0.1·Np)).To each elementmei of E a probability pi which express the likelihood of the element mei to be exploited is assigned. Such a probability is computed as follows:
(12)pi=Ne+1-iNe.
Therefore, the first elements of E have a better probability to be exploited than the last ones. In order to decide if the element mei must be exploited, a uniform random number is generated within the range [0,1]. If such a number is less than pi, then the element mei will be modified by the exploitation operation. Otherwise, it remains without changes.If the exploitation operation overmei is verified, the position of mei is perturbed considering a small neighborhood. The idea is to test if it is possible to refine the solution provided by mei modifying slightly its position. In order to improve the exploitation process, the proposed algorithm starts perturbing the original position within the interval [-D,D] (where D is the distance defined in (11)) and then gradually is reduced as the process evolves. Thus, the perturbation over a generic element mei is modeled as follows:
(13)mei,jnew=mei,j+[Dng-kng](2·rand(0,1)-1),
where k is the current iteration and ng is the total number of iterations from which consists the evolution process. Once meinew has been calculated, its fitness value is computed by using the true objective function (J(meinew)=f(meinew)). If meinew is better than mei according to their fitness values, the value of mei in the original memory M(k+1) is updated with meinew; otherwise the memory M(k+1) remains without changes. The procedure that implements the exploitation operation is presented in Algorithm 5, in form of pseudocode.Algorithm 5:Exploitation operation of APRE.
(1)Input:New memory M(k+1), current iteration k
(2)ME ← SortElementsFitness(M(k+1))
(3)Ne←ceil(0.1·Np)
(4)E ← SelectTheFirstElements(ME,Ne)
(5)fori=1 to Ne do
(6)pi←(Ne+1-i)/Ne
(7)if(rand(0, 1) <= pi) then
(8)forj=1 to n  do
(9)mei,jnew←mei,j+[D((ng-k)/ng)](2·rand(0,1)-1)
(10)end for
(11)  J(meinew)←f(meinew)
(12)if(J(meinew)>J(mei)) then
(13)M(k+1)← MemoryIsUpdated(meinew)
(14)end if
(15)end if
(16)end for
(17)Output:Memory M(k+1)In order to demonstrate the exploitation operation, Figure4(a) illustrates a simple example. A memory M(k+1) of ten different 2-dimensional elements is assumed (Np=10). Figure 4(b) shows the previous configuration of the proposed example before the exploitation operation takes place. Since only the 10% of the best elements of M(k+1) will build the set E, m5 is the single element that constitutes E (me1=m5). Therefore, according to (12), the probability p1 assigned to me1 is 1. Under such circumstances, the element me1 is perturbed considering (13), generating the new position me1new. As me1new is better than me1 according to their fitness values, the value of m5 in the original memory M(k+1) is updated with meinew. Figure 4(c) shows the final configuration of M(k+1) after the exploitation operation has been achieved.Example of the mating operation: (a) function example, (b) initial configuration before the exploitation operation, and (c) configuration after the operation.
(a)
(b)
(c)


### 2.7. Computational Procedure

The computational procedure for the proposed algorithm can be summarized in Algorithm6.Algorithm 6:Computational procedure of APRE.
(1)  Input:Np,Ne0,MR,CH and maxk (where maxk is the maximum number of iterations).
(2)  M(1)← InitializeM(Np)
(3)  c1,…,cNp← ClearCounters()
(4) fork=1 to maxk do
(5)Algorithm1
(6)Algorithm2
(7)Algorithm3
(8)Algorithm4
(9)M(k+1)← UpdateM(M(k))
(10)c1,…,cNp← UpdateCounters(c1,…,cNp)
(11)Q← CalculateQualityFactor(M(k))
(12)Algorithm5
(13)end for
(14)Solution← FindBestElement(M(k))
(15)Output:SolutionThe APRE algorithm is an iterative process in which several actions are executed. After initialization (lines 2-3), the number of memory elements to be evolved are computed. Such number is automatically modified at each iteration (lines 5-6). Then, a set of new individuals is generated as a consequence of the execution of the exploration operation (line 7). For each new individual, its fitness value is estimated or evaluated according to a decision taken by a fitness estimation strategy (line 8). Afterwards, the memory is updated. In this stage, the new individuals produced by the exploration operation compete against the memory elements to build the final memory configuration (lines 9–11). Finally, a sample of the best elements contained in the final memory configuration is undergone to the exploitation operation (line 12). This cycle is repeated until the maximum number of the iterations Maxk has been reached.


## 2.1. Initialization

Like in EA, the APRE algorithm is an iterative method whose first step is to randomly initialize the populationM(k) which will be used as a memory during the evolution process. The algorithm begins by initializing (k=0) a set of Np elements (M(k)={m1,m2,…,mNp}). Each element mi is an n-dimensional vector containing the parameter values to be optimized. Such values are randomly and uniformly distributed between the prespecified lower initial parameter bound pjlow and the upper initial parameter bound pjhigh, just as it described by the following expression:
(1)mi,j=pjlow+rand(0,1)·(pjhigh-pjlow),forj=1,2,…,n,i=1,2,…,Np,
where j and i are the parameter and element indexes, respectively. Hence, mi,j is the jth parameter of the ith element.Each elementmi has two associated characteristics: a fitness value J(mi) and a quality factor Q(mi). The fitness value J(mi) assigned to each element mi can be calculated by using the true objective function f(mi) or only estimated by using the proposed fitness strategy F(mi). In addition to the fitness value, it is also assigned to mi, a normalized fitness value called quality factor Q(mi) (Q(·)∈[0,1]), which is computed as follows:
(2)Q(mi)=J(mi)-worstMbestM-worstM,
where J(mi) is the fitness value obtained by evaluation f(·) or by estimation F(·) of the memory element mi. The values worstM and bestM are defined as follows (considering a maximization problem):
(3)bestM=maxk∈{1,2,…,Np}(J(mk)),worstM=mink∈{1,2,…,Np}(J(mk)).
Since the mechanism by which an EA accumulates information regarding the objective function is an exact evaluation of the quality of each potential solution, initially, all the elements of M(k) are evaluated without considering the fitness estimation strategy proposed in this paper. This fact is only allowed at this initial stage.


## 2.2. Selecting the Population to Be Evolved

At eachk iteration, it must be selected which and how many elements from M(k) will be considered to build the population Pk in order to be evolved. Such selected elements will be undergone by the exploration and exploitation operators in order to generate a set of new individuals. Therefore, two things need to be defined: the number of elements Nek to be selected and the strategy of selection.


### 2.2.1. The Number of ElementsNek to Be Selected

One of the mechanisms used by the APRE algorithm for reducing the number of function evaluations is to modify dynamically the size of the population to be evolved. The idea is to operate with the minimal number of individuals that guarantee the correct efficiency of the algorithm. Hence, the method aims to vary the population size in an adaptive way during the execution of each iteration. At the beginning of the process, a predetermined numberNe0 of elements are considered to build the first population; then, it will be incremented or decremented depending on the algorithm’s performance. The adaptation mechanism is based on the lifetime of the individuals and on their solution quality.In order to compute the lifetime of each individual, it is assigned a counterci (i∈(1,2,3,…,Np)) to each element mi of M(k). When the initial population M(k) is created, all the counters are set to zero. Since the memory M(k) is updated at each generation, some elements prevail and others will be substituted by new individuals. Therefore, the counter of the surviving elements is incremented by one whereas the counter of new added elements is set to zero.Another important requirement to calculate the number of elements to be evolved is the solution quality provided by each individual. The idea is to identify two classes of elements, those that provide good solutions and those that can be considered as bad solutions. In order to classify each element, the average fitness valueJA produced by all the elements of M(k) is calculated as
(4)JA=1Np∑i=1NpJ(mi),
where J(·) represents the fitness value corresponding to mi. These values are evaluated either by the true objective function f(mi) or by the fitness estimation strategy F(mi). Considering the average fitness value, two groups are built: the set G constituted by the elements of M(k) whose fitness values are greater than JA and the set B which groups the elements of M(k) whose fitness values are equal or lower than JA.Therefore, the number of individuals of the current population that will be incremented or decremented at each generation is calculated by the following model:(5)A=floor(|G|·∑l∈Gcl-|B|·∑q∈Bcqs),
where the floor (·) function maps a real number to the previous integer. |G| and |B| represent the number of elements of G and B, respectively, whereas ∑l∈Gcl and ∑q∈Bcq indicate the sum of the counters that correspond to the elements of G and B, respectively. The factor s is a term used for fine tuning. A small value of s implies a better algorithm’s performance at the price of an increment in the computational cost. On the other hand, a big value of s involves a low computational cost at the price of a decrement in the performance algorithm. Therefore, the s value must reflex a compromise between performance and computational cost. In our experiments such compromise has been found with s=10.Therefore, the number the elements that define the population to be evolved is computed according to the following model:(6)Nek=Nek-1+A.
Since the value of A can be positive or negative, the size of the population Pk may be higher or lesser than Pk-1. The computational procedure that implements this method is presented in Algorithm 1, in form of pseudocode.Algorithm 1:Selection of the number of individuals Nek to be evolved.
(1)Input:Current population M(k), counters c1,…,cNp,
the past number of individualsNek-1 and the constant factor s.
(2)JA←(1/Np)∑i=1NpJ(mi)
(3)G← FindIndividualsOverJA(M(k),JA)
(4)B← FindIndividualsUnderJA(M(k),JA)
(5)cl← FindCountersOfG(G) (Where l∈G)
(6)cq← FindCountersOfB(B) (Where q∈B)
(7)A←floor((|G|·∑l∈Gcl-|B|·∑q∈Bcq)/s)
(8)Nek←Nek-1+A
(9)Output:The number Nek


### 2.2.2. Selection Strategy for BuildingPk

Once the number of individuals has been defined, the next step is the selection ofNek elements from M(k) for building Pk. A new population MO which contains the same elements that M(k) is generated but sorted according to their fitness values. Thus, MO presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, MO is divided in two parts: X and Y. The section X corresponds to the first Nek elements of MO whereas the rest of the elements constitute the part Y. Figure 1 shows this process.Figure 1
Necessary postprocessing implemented by the selection strategy.In order to promote diversity, in the selection strategy, the 80% of theNek individuals of Pk are taken from the first elements of X and named as Fe as shown in Figure 2, where Fe=floor (0.8*Nek). The remaining 20% of the individuals are randomly selected from section Y. Hence, the last set of Se elements (where Se=Nek-Fe) is chosen considering that all elements of Y have the same possibility of being selected. Figure 2 shows a description of the selection strategy. The computational procedure that implements this method is presented in Algorithm 2, in form of pseudocode.Algorithm 2:Selection strategy for building Pk.
(1)Input:Current population M(k) and the number of individuals Nek.
(2)MO← SortElementsFitness(M(k))
(3)[X,Y]← DivideMO(MO,Nek)
(4)Fe← floor(0.8*Nek)
(5)Se←Nek-Fe
(6)(p1k,…,pFek)← SelectElementsOfX(X,Fe)
(7)(pFe+1k,…,pFe+Sek)← SelectRandomElementsOfY(Y,Se)
(8)Output:Population Pk to be evolveFigure 2
Employed selection strategy to build the populationPk, where d,g∈Y.


## 2.2.1. The Number of ElementsNek to Be Selected

One of the mechanisms used by the APRE algorithm for reducing the number of function evaluations is to modify dynamically the size of the population to be evolved. The idea is to operate with the minimal number of individuals that guarantee the correct efficiency of the algorithm. Hence, the method aims to vary the population size in an adaptive way during the execution of each iteration. At the beginning of the process, a predetermined numberNe0 of elements are considered to build the first population; then, it will be incremented or decremented depending on the algorithm’s performance. The adaptation mechanism is based on the lifetime of the individuals and on their solution quality.In order to compute the lifetime of each individual, it is assigned a counterci (i∈(1,2,3,…,Np)) to each element mi of M(k). When the initial population M(k) is created, all the counters are set to zero. Since the memory M(k) is updated at each generation, some elements prevail and others will be substituted by new individuals. Therefore, the counter of the surviving elements is incremented by one whereas the counter of new added elements is set to zero.Another important requirement to calculate the number of elements to be evolved is the solution quality provided by each individual. The idea is to identify two classes of elements, those that provide good solutions and those that can be considered as bad solutions. In order to classify each element, the average fitness valueJA produced by all the elements of M(k) is calculated as
(4)JA=1Np∑i=1NpJ(mi),
where J(·) represents the fitness value corresponding to mi. These values are evaluated either by the true objective function f(mi) or by the fitness estimation strategy F(mi). Considering the average fitness value, two groups are built: the set G constituted by the elements of M(k) whose fitness values are greater than JA and the set B which groups the elements of M(k) whose fitness values are equal or lower than JA.Therefore, the number of individuals of the current population that will be incremented or decremented at each generation is calculated by the following model:(5)A=floor(|G|·∑l∈Gcl-|B|·∑q∈Bcqs),
where the floor (·) function maps a real number to the previous integer. |G| and |B| represent the number of elements of G and B, respectively, whereas ∑l∈Gcl and ∑q∈Bcq indicate the sum of the counters that correspond to the elements of G and B, respectively. The factor s is a term used for fine tuning. A small value of s implies a better algorithm’s performance at the price of an increment in the computational cost. On the other hand, a big value of s involves a low computational cost at the price of a decrement in the performance algorithm. Therefore, the s value must reflex a compromise between performance and computational cost. In our experiments such compromise has been found with s=10.Therefore, the number the elements that define the population to be evolved is computed according to the following model:(6)Nek=Nek-1+A.
Since the value of A can be positive or negative, the size of the population Pk may be higher or lesser than Pk-1. The computational procedure that implements this method is presented in Algorithm 1, in form of pseudocode.Algorithm 1:Selection of the number of individuals Nek to be evolved.
(1)Input:Current population M(k), counters c1,…,cNp,
the past number of individualsNek-1 and the constant factor s.
(2)JA←(1/Np)∑i=1NpJ(mi)
(3)G← FindIndividualsOverJA(M(k),JA)
(4)B← FindIndividualsUnderJA(M(k),JA)
(5)cl← FindCountersOfG(G) (Where l∈G)
(6)cq← FindCountersOfB(B) (Where q∈B)
(7)A←floor((|G|·∑l∈Gcl-|B|·∑q∈Bcq)/s)
(8)Nek←Nek-1+A
(9)Output:The number Nek


## 2.2.2. Selection Strategy for BuildingPk

Once the number of individuals has been defined, the next step is the selection ofNek elements from M(k) for building Pk. A new population MO which contains the same elements that M(k) is generated but sorted according to their fitness values. Thus, MO presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, MO is divided in two parts: X and Y. The section X corresponds to the first Nek elements of MO whereas the rest of the elements constitute the part Y. Figure 1 shows this process.Figure 1
Necessary postprocessing implemented by the selection strategy.In order to promote diversity, in the selection strategy, the 80% of theNek individuals of Pk are taken from the first elements of X and named as Fe as shown in Figure 2, where Fe=floor (0.8*Nek). The remaining 20% of the individuals are randomly selected from section Y. Hence, the last set of Se elements (where Se=Nek-Fe) is chosen considering that all elements of Y have the same possibility of being selected. Figure 2 shows a description of the selection strategy. The computational procedure that implements this method is presented in Algorithm 2, in form of pseudocode.Algorithm 2:Selection strategy for building Pk.
(1)Input:Current population M(k) and the number of individuals Nek.
(2)MO← SortElementsFitness(M(k))
(3)[X,Y]← DivideMO(MO,Nek)
(4)Fe← floor(0.8*Nek)
(5)Se←Nek-Fe
(6)(p1k,…,pFek)← SelectElementsOfX(X,Fe)
(7)(pFe+1k,…,pFe+Sek)← SelectRandomElementsOfY(Y,Se)
(8)Output:Population Pk to be evolveFigure 2
Employed selection strategy to build the populationPk, where d,g∈Y.


## 2.3. Exploration Operation

The first main operation applied to the populationPk is the exploration operation. Considering Pk as the input population, APRE mutates Pk to produce a temporal population Tk of Nek vectors. In the exploration operation two different mutation models are used: the mutation employed by the Differential Evolution algorithm (DE) [27] and the trigonometric mutation operator [28].


### 2.3.1. DE Mutation Operator

In this mutation, three distinct individualsr1, r2, and r3 are randomly selected from the current population Pk. Then, a new value hi,j considering the following model is created:
(7)hi,j=pr1,j+F(pr2,j-pr3,j),
where r1, r2, and r3 are randomly selected individuals such that they satisfy r1≠r2≠r3≠i, i=1 to Nek (population size), and j=1 to n (number of decision variable). Hence, pi,j is the jth parameter of the ith individual of Pk. The scale factor, F(0,1+), is a positive real number that controls the rate at which the population evolves.


### 2.3.2. Trigonometric Mutation Operator

The trigonometric mutation operation is performed according to the following formulation:(8)hi,j=pAv(j)+F1(pr1,j-pr2,j)+F2(pr2,j-pr3,j)+F3(pr3,j-pr1,j),pAv(j)=pr1,j+pr2,j+pr3,j3,F1=(dr2-dr1),F2=(dr3-dr2),F3=(dr1-dr3),dr1=|J(pr1)|dT,dr2=|J(pr2)|dT,dr3=|J(pr3)|dT,dT=|J(pr1)|+|J(pr2)|+|J(pr3)|,
where pr1, pr2, and pr3 represent the individuals r1, r2, and r3 randomly selected from the current population Pk whereas J(·) represents the fitness value (calculated or estimated) corresponding to pi. Under this formulation, the individual pAv(j) to be perturbed is the average value of three randomly selected vectors (r1, r2, and r3). The perturbation to be imposed over such individual is implemented by the sum of three weighted vector differentials. F1, F2, and F3 are the weights applied to these vector differentials. Notice that the trigonometric mutation is a greedy operator since it biases the pAv(j) strongly in the direction where the best one of three individuals is lying.Computational Procedure. Considering Pk as the input population, all its Nek individuals are sequentially processed in cycles beginning by the first individual p1. Therefore, in the cycle i (where it is processed the individual i), three distinct individuals r1, r2, and r3 are randomly selected from the current population considering that they satisfy the following conditions r1≠r2≠r3≠i. Then, it is processed each dimension of pi beginning by the first parameter 1 until the last dimension n has been reached. At each processing cycle, the parameter pi,j considered as a parent, creates an offspring ti,j in two steps. In the first step, from the selected individuals r1, r2, and r3, a donor vector hi,j is created by means of two different mutation models. In order to select which mutation model is applied, a uniform random number is generated within the range [0,1]. If such number is less than a threshold MR, the donor vector hi,j is generated by the DE mutation operator; otherwise, it is produced by the trigonometric mutation operator. Such process can be modeled as follows:
(9)hi,j={Byusing(7)withprobabilityMRByusing(8)withprobability(1-MR).
In the second step, the final value of the offspring ti,j is determined. Such decision is stochastic; hence, a second uniform random number is generated within the range [0,1]. If this random number is less than CH, ti,j=hi,j; otherwise, ti,j=pi,j. This operation can be formulated as follows:
(10)ti,j={hi,jwithprobabilityCHpi,jwithprobability(1-CH).
The complete computational procedure is presented in Algorithm 3, in form of pseudocode.Algorithm 3:Exploration operation of APRE algorithm.
(1)  Input:Current population Pk
(2)fori=1 to Nek do
(3)  (pr1,pr2,pr3)← SelectElements()  % Considering that r1≠r2≠r3≠i
(4)for j=1 to n  do
(5)if (rand(0,1)<=MR) then
(6)hi,j← DEMutation(pr1,pr2,pr3) % (7)
(7)else
(8)hi,j← TrigonometricMutation(pr1,pr2,pr3) % (8)
(9)end if
(10)if(rand(0,1)<=CH) then
(11)ti,j←hi,j
(12)else
(13) ti,j←pi,j
(14)end if
(15)end for
(16)end for
(17)Output:Population Tk


## 2.3.1. DE Mutation Operator

In this mutation, three distinct individualsr1, r2, and r3 are randomly selected from the current population Pk. Then, a new value hi,j considering the following model is created:
(7)hi,j=pr1,j+F(pr2,j-pr3,j),
where r1, r2, and r3 are randomly selected individuals such that they satisfy r1≠r2≠r3≠i, i=1 to Nek (population size), and j=1 to n (number of decision variable). Hence, pi,j is the jth parameter of the ith individual of Pk. The scale factor, F(0,1+), is a positive real number that controls the rate at which the population evolves.


## 2.3.2. Trigonometric Mutation Operator

The trigonometric mutation operation is performed according to the following formulation:(8)hi,j=pAv(j)+F1(pr1,j-pr2,j)+F2(pr2,j-pr3,j)+F3(pr3,j-pr1,j),pAv(j)=pr1,j+pr2,j+pr3,j3,F1=(dr2-dr1),F2=(dr3-dr2),F3=(dr1-dr3),dr1=|J(pr1)|dT,dr2=|J(pr2)|dT,dr3=|J(pr3)|dT,dT=|J(pr1)|+|J(pr2)|+|J(pr3)|,
where pr1, pr2, and pr3 represent the individuals r1, r2, and r3 randomly selected from the current population Pk whereas J(·) represents the fitness value (calculated or estimated) corresponding to pi. Under this formulation, the individual pAv(j) to be perturbed is the average value of three randomly selected vectors (r1, r2, and r3). The perturbation to be imposed over such individual is implemented by the sum of three weighted vector differentials. F1, F2, and F3 are the weights applied to these vector differentials. Notice that the trigonometric mutation is a greedy operator since it biases the pAv(j) strongly in the direction where the best one of three individuals is lying.Computational Procedure. Considering Pk as the input population, all its Nek individuals are sequentially processed in cycles beginning by the first individual p1. Therefore, in the cycle i (where it is processed the individual i), three distinct individuals r1, r2, and r3 are randomly selected from the current population considering that they satisfy the following conditions r1≠r2≠r3≠i. Then, it is processed each dimension of pi beginning by the first parameter 1 until the last dimension n has been reached. At each processing cycle, the parameter pi,j considered as a parent, creates an offspring ti,j in two steps. In the first step, from the selected individuals r1, r2, and r3, a donor vector hi,j is created by means of two different mutation models. In order to select which mutation model is applied, a uniform random number is generated within the range [0,1]. If such number is less than a threshold MR, the donor vector hi,j is generated by the DE mutation operator; otherwise, it is produced by the trigonometric mutation operator. Such process can be modeled as follows:
(9)hi,j={Byusing(7)withprobabilityMRByusing(8)withprobability(1-MR).
In the second step, the final value of the offspring ti,j is determined. Such decision is stochastic; hence, a second uniform random number is generated within the range [0,1]. If this random number is less than CH, ti,j=hi,j; otherwise, ti,j=pi,j. This operation can be formulated as follows:
(10)ti,j={hi,jwithprobabilityCHpi,jwithprobability(1-CH).
The complete computational procedure is presented in Algorithm 3, in form of pseudocode.Algorithm 3:Exploration operation of APRE algorithm.
(1)  Input:Current population Pk
(2)fori=1 to Nek do
(3)  (pr1,pr2,pr3)← SelectElements()  % Considering that r1≠r2≠r3≠i
(4)for j=1 to n  do
(5)if (rand(0,1)<=MR) then
(6)hi,j← DEMutation(pr1,pr2,pr3) % (7)
(7)else
(8)hi,j← TrigonometricMutation(pr1,pr2,pr3) % (8)
(9)end if
(10)if(rand(0,1)<=CH) then
(11)ti,j←hi,j
(12)else
(13) ti,j←pi,j
(14)end if
(15)end for
(16)end for
(17)Output:Population Tk


## 2.4. Fitness Estimation Strategy

Once the populationTk has been generated by the exploration operation, it is necessary to calculate the fitness value provided by each individual. In order to reduce the number of function evaluations, a fitness estimation strategy that decides which individuals can be estimated or actually evaluated is introduced. The idea of such a strategy is to find the global optimum of a given function considering only very few number of function evaluations.In this paper, we explore a local approximation scheme that estimates the fitness values based on previously evaluated neighboring individuals, stored in the memoryM(k) during the evolution process. The strategy decides if an individual ti is calculated or estimated based on two criteria. The first one considers the distance between ti and the nearest element mne contained in M(k) (where mn∈(m1,m2,…,mNp)) whereas the second one examines the quality factor provided by the nearest element mne(Q(mne)).In the model, individuals ofTk that are near the elements of M(k) holding the best quality values have a high probability to be evaluated. Such individuals are important, since they will have a stronger influence on the evolution process than other individuals. In contrast, individuals of Tk that are also near the elements of M(k) but with a bad quality value maintain a very low probability to be evaluated. Thus, most of such individuals will only be estimated, assigning it the same fitness value that the nearest element of M(k). On the other hand, those individuals in regions of the search space with few previous evaluations (individuals of Tk located farther than a distance D) are also evaluated. The fitness values of these individuals are uncertain since there is no close reference (close points contained in M(k)).Therefore, the fitness estimation strategy follows two rules in order to evaluate or estimate the fitness values.(1)
If the new individualti is located closer than a distance D with respect to the nearest element mne stored in M, then a uniform random number is generated within the range [0,1]. If such number is less than Q(mne), ti is evaluated by the true objective function (f(ti)). Otherwise, its fitness value is estimated assigning it the same fitness value that mne (F(ti)=J(mne)). Figures 3(a) and 3(b) draw the rule procedure.(2)
If the new individualti is located longer than a distance D with respect to the nearest individual location mne stored in M, then the fitness value of ti is evaluated using the true objective function (f(ti)). Figure 3(c) outlines the rule procedure.The fitness estimation strategy. (a) According to the rule  1, the individualti has a high probability to be evaluated f(t1), since it is located closer than a distance D with respect to the nearest element mne=m1 whose quality factor Q(m1) corresponds to the best value. (b) According to the rule  1, the individual ti has a high probability to be estimated F(t1) (assigning it the same fitness value as mne (F(ti)=J(m3))), since it is located closer than a distance D with respect to the nearest element mne=m3 whose quality factor Q(m3) corresponds to the worst value. (c) According to the rule  2, the individual ti is evaluated, as there is no close reference in its neighborhood.
(a)
(b)
(c)From the rules, the distanceD controls the trade off between the evaluation and estimation of new individuals. Unsuitable values of D result in a lower convergence rate, longer computation time, larger function evaluation number, convergence to a local maximum, or unreliability of solutions. Therefore, the D value is computed considering the following equation:
(11)D=∑j=1n(pjhigh-pjlow)50·n,
where pjlow and pjhigh represent the prespecified lower bound and the upper bound of the j-parameter, respectively, within an n-dimensional space. Both rules show that the fitness estimation strategy is simple and straightforward. Figure 3 illustrates the procedure of fitness computation for a new candidate solution ti considering the two different rules. In the problem the objective function f is maximized with respect to two parameters (x1,x2). In all figures (Figures 3(a), 3(b), and 3(c)) the memory M(k) contains five different elements (m1,m2,m3,m4,  and m5) with their corresponding fitness values (J(m1),J(m2),J(m3),J(m4), and J(m5)) and quality factors (Q(m1),Q(m2),Q(m3),Q(m4), and Q(m5)). Figures 3(a) and 3(b) show the fitness evaluation (f(x1,x2)) or estimation (F(x1,x2)) of the new individual ti following the rule  1. Figure 3(a) represents the case when mne holds a good quality factor whereas Figure 3(b) when mne maintains a bad quality factor. Finally, Figure 3(c) presents the fitness evaluation of ti considering the conditions of rule  2. The procedure that implements the fitness estimation strategy is presented in Algorithm 4, in form of pseudocode.Algorithm 4:Fitness estimation strategy.
(1)  Input:Population Tk and memory M(k)
(2)fori=1 to Nek do
(3)  mne← FindNearestElementOfM(ti)
(4)distance← FindTheDistance(ti,mne)
(5)if (distance < D) then
(6)if (rand(0, 1) <= Q(mne)) then
(7)J(ti)←f(ti) % Evaluation
(8)  else              (Rule  1)
(9)J(ti)←J(mne) % Estimation
(10)end if
(11)  else
(12)J(ti)←f(ti)   % Evaluation  (Rule  2)
(13)end if
(14)end for
(15)Output:fitness values of  Tk


## 2.5. Memory Updating

Once the operations of exploration and fitness estimation have been applied, it is necessary to update the memoryM(k). In the APRE algorithm, the memory M(k) is updated considering the following procedure.(1)
The elements ofM(k) and Tk are merged into MU (MU=M(k)∪Tk).(2)
From the resulting elements ofMU, it is selected the Np best elements according to their fitness values to build the new memory M(k+1).(3)
The countersc1,c2,…,cNp must be updated. Thus, the counter of the surviving elements is incremented by 1 whereas the counter of modified elements is set to zero.


## 2.6. Exploitation Operation

The second main operation applied by the APRE algorithm is the exploitation operation. Exploitation, in the context of EA, is the process of refining the solution quality of existent promising solutions within a small neighborhood. In order to implement such a process, a new memoryME is generated, which contains the same elements that M(k+1) but sorted according to their fitness values. Thus, ME presents in its first positions the elements whose fitness values are better than those located in the last positions. Then, the 10% of the Np (Ne) individuals are taken from the first elements of ME to build the set E (E={me1,me2,…,meNe}, where Ne=ceil(0.1·Np)).To each elementmei of E a probability pi which express the likelihood of the element mei to be exploited is assigned. Such a probability is computed as follows:
(12)pi=Ne+1-iNe.
Therefore, the first elements of E have a better probability to be exploited than the last ones. In order to decide if the element mei must be exploited, a uniform random number is generated within the range [0,1]. If such a number is less than pi, then the element mei will be modified by the exploitation operation. Otherwise, it remains without changes.If the exploitation operation overmei is verified, the position of mei is perturbed considering a small neighborhood. The idea is to test if it is possible to refine the solution provided by mei modifying slightly its position. In order to improve the exploitation process, the proposed algorithm starts perturbing the original position within the interval [-D,D] (where D is the distance defined in (11)) and then gradually is reduced as the process evolves. Thus, the perturbation over a generic element mei is modeled as follows:
(13)mei,jnew=mei,j+[Dng-kng](2·rand(0,1)-1),
where k is the current iteration and ng is the total number of iterations from which consists the evolution process. Once meinew has been calculated, its fitness value is computed by using the true objective function (J(meinew)=f(meinew)). If meinew is better than mei according to their fitness values, the value of mei in the original memory M(k+1) is updated with meinew; otherwise the memory M(k+1) remains without changes. The procedure that implements the exploitation operation is presented in Algorithm 5, in form of pseudocode.Algorithm 5:Exploitation operation of APRE.
(1)Input:New memory M(k+1), current iteration k
(2)ME ← SortElementsFitness(M(k+1))
(3)Ne←ceil(0.1·Np)
(4)E ← SelectTheFirstElements(ME,Ne)
(5)fori=1 to Ne do
(6)pi←(Ne+1-i)/Ne
(7)if(rand(0, 1) <= pi) then
(8)forj=1 to n  do
(9)mei,jnew←mei,j+[D((ng-k)/ng)](2·rand(0,1)-1)
(10)end for
(11)  J(meinew)←f(meinew)
(12)if(J(meinew)>J(mei)) then
(13)M(k+1)← MemoryIsUpdated(meinew)
(14)end if
(15)end if
(16)end for
(17)Output:Memory M(k+1)In order to demonstrate the exploitation operation, Figure4(a) illustrates a simple example. A memory M(k+1) of ten different 2-dimensional elements is assumed (Np=10). Figure 4(b) shows the previous configuration of the proposed example before the exploitation operation takes place. Since only the 10% of the best elements of M(k+1) will build the set E, m5 is the single element that constitutes E (me1=m5). Therefore, according to (12), the probability p1 assigned to me1 is 1. Under such circumstances, the element me1 is perturbed considering (13), generating the new position me1new. As me1new is better than me1 according to their fitness values, the value of m5 in the original memory M(k+1) is updated with meinew. Figure 4(c) shows the final configuration of M(k+1) after the exploitation operation has been achieved.Example of the mating operation: (a) function example, (b) initial configuration before the exploitation operation, and (c) configuration after the operation.
(a)
(b)
(c)


## 2.7. Computational Procedure

The computational procedure for the proposed algorithm can be summarized in Algorithm6.Algorithm 6:Computational procedure of APRE.
(1)  Input:Np,Ne0,MR,CH and maxk (where maxk is the maximum number of iterations).
(2)  M(1)← InitializeM(Np)
(3)  c1,…,cNp← ClearCounters()
(4) fork=1 to maxk do
(5)Algorithm1
(6)Algorithm2
(7)Algorithm3
(8)Algorithm4
(9)M(k+1)← UpdateM(M(k))
(10)c1,…,cNp← UpdateCounters(c1,…,cNp)
(11)Q← CalculateQualityFactor(M(k))
(12)Algorithm5
(13)end for
(14)Solution← FindBestElement(M(k))
(15)Output:SolutionThe APRE algorithm is an iterative process in which several actions are executed. After initialization (lines 2-3), the number of memory elements to be evolved are computed. Such number is automatically modified at each iteration (lines 5-6). Then, a set of new individuals is generated as a consequence of the execution of the exploration operation (line 7). For each new individual, its fitness value is estimated or evaluated according to a decision taken by a fitness estimation strategy (line 8). Afterwards, the memory is updated. In this stage, the new individuals produced by the exploration operation compete against the memory elements to build the final memory configuration (lines 9–11). Finally, a sample of the best elements contained in the final memory configuration is undergone to the exploitation operation (line 12). This cycle is repeated until the maximum number of the iterations Maxk has been reached.


## 3. Implementation of APRE-Based Circle Detector

### 3.1. Individual Representation

In order to detect circle shapes, candidate images must be preprocessed first by the well-known Canny algorithm which yields a single-pixel edge-only image. Then, the(xi,yi) coordinates for each edge pixel ei are stored inside the edge vector E={e1,e2,…,ezn}, with zn being the total number of edge pixels. Each circle C uses three edge points as individuals in the optimization algorithm. In order to construct such individuals, three indexes ei, ej, and ek, are selected from vector E, considering the circle’s contour that connects them. Therefore, the circle C={ei,ej,ek} that crosses over such points may be considered as a potential solution for the detection problem. Considering the configuration of the edge points shown by Figure 5, the circle center (x0,y0) and the radius r of C can be computed as follows:
(14)(x-x0)2+(y-y0)2=r2.
Considering
(15)A=[xj2+yj2-(xi2+yi2)2·(yj-yi)xk2+yk2-(xi2+yi2)2·(yk-yi)],B=[2·(xj-xi)xj2+yj2-(xi2+yi2)2·(xk-xi)xk2+yk2-(xi2+yi2)],x0=det(A)4((xj-xi)(yk-yi)-(xk-xi)(yj-yi)),y0=det(B)4((xj-xi)(yk-yi)-(xk-xi)(yj-yi)),r=(x0-xd)2+(y0-yd)2,
where det(·) is the determinant and d∈{i,j,k}. Figure 5 illustrates the parameters defined by (14) to (17).Figure 5
Circle candidate (individual) built from the combination of pointsei, ej, and ek.


### 3.2. Objective Function

In order to calculate the error produced by a candidate solutionC, a set of test points is calculated as a virtual shape which, in turn, must be validated, that is, if it really exists in the edge image. The test set is represented by A={a1,a2,…,asn}, where sn is the number of points over which the existence of an edge point, corresponding to C, should be validated. In our approach, the set A is generated by the Midpoint Circle Algorithm (MCA) [29]. The MCA is a searching method which seeks the required points for drawing a circle digitally. Therefore, MCA calculates the necessary number of test points sn to totally draw the complete circle. Such a method is considered the fastest because MCA avoids computing square-root calculations by comparing the pixel separation distances among them.The objective functionJ(C) represents the matching error produced between the pixels A of the circle candidate C (individual) and the pixels that actually exist in the edge image, yielding
(16)J(C)=∑v=1snG(av)sn,
where G(av) is a function that verifies the pixel existence in av, with av∈A and sn being the number of pixels lying on the perimeter corresponding to C currently under testing. Hence, function G(av) is defined as
(17)G(av)={1,ifthepixel(av)isanedgepoint,0,otherwise.
A value of J(C) near to one implies a better response from the “circularity” operator. Figure 6 shows the procedure to evaluate a candidate solution C by using the objective function J(C). Figure 6(a) shows the original edge map E, while Figure 6(b) presents the virtual shape A representing the particle C={ei,ej,ek}. In Figure 6(c), the virtual shape A is compared to the edge image, point by point, in order to find coincidences between virtual and edge points. The particle has been built from points ei, ej, and ek which are shown by Figure 6(a). The virtual shape A, obtained by MCA, gathers 56 points (sn=56) with only 17 of them existing in both images (shown as white points in Figure 6(c)) and yielding ∑v=1snG(av)=17, therefore J(C)≈0.30.Procedure to evaluate the objective functionJ(C). The image (a) presents the original edge map while (b) present the virtual shape A corresponding to C. The image (c) shows the coincidences between both images by means of white pixels whereas the virtual shape is depicted in black.
(a)
(b)
(c)


### 3.3. The Multiple Circle Detection Procedure

In order to detect multiple circles, the APRE-detector is iteratively applied. At each iteration, two actions are developed. In the first one, a new circle is detected as a consequence of the execution of the APRE algorithm. The detected circle corresponds to the candidate solutionC with the best found J(C) value. In the second one, the detected circle is removed from the original edge map. The processed edge map without the removed circle represents the input image for the next iteration. Such process is executed over the sequence of images until the J(C) value would be lower than a determined threshold that is considered as permissible.


## 3.1. Individual Representation

In order to detect circle shapes, candidate images must be preprocessed first by the well-known Canny algorithm which yields a single-pixel edge-only image. Then, the(xi,yi) coordinates for each edge pixel ei are stored inside the edge vector E={e1,e2,…,ezn}, with zn being the total number of edge pixels. Each circle C uses three edge points as individuals in the optimization algorithm. In order to construct such individuals, three indexes ei, ej, and ek, are selected from vector E, considering the circle’s contour that connects them. Therefore, the circle C={ei,ej,ek} that crosses over such points may be considered as a potential solution for the detection problem. Considering the configuration of the edge points shown by Figure 5, the circle center (x0,y0) and the radius r of C can be computed as follows:
(14)(x-x0)2+(y-y0)2=r2.
Considering
(15)A=[xj2+yj2-(xi2+yi2)2·(yj-yi)xk2+yk2-(xi2+yi2)2·(yk-yi)],B=[2·(xj-xi)xj2+yj2-(xi2+yi2)2·(xk-xi)xk2+yk2-(xi2+yi2)],x0=det(A)4((xj-xi)(yk-yi)-(xk-xi)(yj-yi)),y0=det(B)4((xj-xi)(yk-yi)-(xk-xi)(yj-yi)),r=(x0-xd)2+(y0-yd)2,
where det(·) is the determinant and d∈{i,j,k}. Figure 5 illustrates the parameters defined by (14) to (17).Figure 5
Circle candidate (individual) built from the combination of pointsei, ej, and ek.


## 3.2. Objective Function

In order to calculate the error produced by a candidate solutionC, a set of test points is calculated as a virtual shape which, in turn, must be validated, that is, if it really exists in the edge image. The test set is represented by A={a1,a2,…,asn}, where sn is the number of points over which the existence of an edge point, corresponding to C, should be validated. In our approach, the set A is generated by the Midpoint Circle Algorithm (MCA) [29]. The MCA is a searching method which seeks the required points for drawing a circle digitally. Therefore, MCA calculates the necessary number of test points sn to totally draw the complete circle. Such a method is considered the fastest because MCA avoids computing square-root calculations by comparing the pixel separation distances among them.The objective functionJ(C) represents the matching error produced between the pixels A of the circle candidate C (individual) and the pixels that actually exist in the edge image, yielding
(16)J(C)=∑v=1snG(av)sn,
where G(av) is a function that verifies the pixel existence in av, with av∈A and sn being the number of pixels lying on the perimeter corresponding to C currently under testing. Hence, function G(av) is defined as
(17)G(av)={1,ifthepixel(av)isanedgepoint,0,otherwise.
A value of J(C) near to one implies a better response from the “circularity” operator. Figure 6 shows the procedure to evaluate a candidate solution C by using the objective function J(C). Figure 6(a) shows the original edge map E, while Figure 6(b) presents the virtual shape A representing the particle C={ei,ej,ek}. In Figure 6(c), the virtual shape A is compared to the edge image, point by point, in order to find coincidences between virtual and edge points. The particle has been built from points ei, ej, and ek which are shown by Figure 6(a). The virtual shape A, obtained by MCA, gathers 56 points (sn=56) with only 17 of them existing in both images (shown as white points in Figure 6(c)) and yielding ∑v=1snG(av)=17, therefore J(C)≈0.30.Procedure to evaluate the objective functionJ(C). The image (a) presents the original edge map while (b) present the virtual shape A corresponding to C. The image (c) shows the coincidences between both images by means of white pixels whereas the virtual shape is depicted in black.
(a)
(b)
(c)


## 3.3. The Multiple Circle Detection Procedure

In order to detect multiple circles, the APRE-detector is iteratively applied. At each iteration, two actions are developed. In the first one, a new circle is detected as a consequence of the execution of the APRE algorithm. The detected circle corresponds to the candidate solutionC with the best found J(C) value. In the second one, the detected circle is removed from the original edge map. The processed edge map without the removed circle represents the input image for the next iteration. Such process is executed over the sequence of images until the J(C) value would be lower than a determined threshold that is considered as permissible.


## 4. Results on Multicircle Detection

In order to achieve the performance analysis, the proposed approach is compared to the GA-based algorithm [5], the BFAO detector [9] and the RHT method [4] over an image set.The GA-based algorithm follows the proposal of Ayala-Ramirez et al. [5], which considers the population size as 70, the crossover probability as 0.55, the mutation probability as 0.10, and the number of elite individuals as 2 and 200 generations. The roulette wheel selection and the 1-point crossover operator are both applied. The parameter setup and the fitness function follow the configuration suggested in [5]. The BFAO algorithm follows the implementation from [9] considering the experimental parameters as S=50, Nc=350, Ns=4, Ned=1, Ped=0.25, dattract=0.1, wattract=0.2, wrepellant=10, hrepellant=0.1, λ=400, and ψ=6. Such values are found to be the best configuration set according to [9]. Both, the GA-based algorithm and the BAFO method use the same objective function that is defined by (16). Likewise, the RHT method has been implemented as it is described in [4]. Finally, Table 1 presents the parameters for the APRE algorithm used in this work. They have been kept for all test images after being experimentally defined.Table 1
APRE detector parameters.
N
p
N
e
0
MR
CH
max
k
50
20
0.6
0.8
200Images rarely contain perfectly-shaped circles. Therefore, with the purpose of testing accuracy for a single-circle, the detection is challenged by a ground-truth circle which is determined from the original edge map. The parameters(xtrue,  ytrue, and rtrue) representing the testing circle are computed using the (6)–(9) for three circumference points over the manually-drawn circle. Considering the centre and the radius of the detected circle are defined as (xD,yD) and rD, the Error Score (Es) can be accordingly calculated as
(18)Es=η·(|xtrue-xD|+|ytrue-yD|)+μ·|rtrue-rD|.
The central point difference (|xtrue-xD|+|ytrue-yD|) represents the centre shift for the detected circle as it is compared to a benchmark circle. The radio mismatch (|rtrue-rD|) accounts for the difference between their radii. η and μ represent two weighting parameters which are to be applied separately to the central point difference and to the radio mismatch for the final error Es. At this work, they are chosen as η=0.05 and μ=0.1. Such a choice ensures that the radius difference would be strongly weighted in comparison to the difference of central circular positions between the manually detected and the machine-detected circles. Here, we assume that if Es is found to be less than 1, then the algorithm gets a success; otherwise, we say that it has failed to detect the edge-circle. Note that for η=0.05 and μ=0.1Es<1 means the maximum difference of radius tolerated is 10, while the maximum mismatch in the location of the center can be 20 (in number of pixels). In order to appropriately compare the detection results, the Detection Rate (DR) is introduced as a performance index. DR is defined as the percentage of reaching detection success after a certain number of trials. For “success” it does mean that the compared algorithm is able to detect all circles contained in the image, under the restriction that each circle must hold the condition Es<1. Therefore, if at least one circle does not fulfil the condition of Es<1, the complete detection procedure is considered as a failure.In order to use an error metric for multiple-circle detection, the averaged Es produced from each circle in the image is considered. Such criterion, defined as the Multiple Error (ME), is calculated as follows:(19)ME=(1NC)·∑R=1NCEsR,
where NC represents the number of circles within the image according to a human expert.Figure7 shows three synthetic images and the resulting images after applying the GA-based algorithm [5], the BFOA method [9], and the proposed approach. Figure 8 presents experimental results considering three natural images. The performance is analyzed by considering 35 different executions for each algorithm. Table 2 shows the averaged execution time, the averaged number of function evaluations, the detection rate in percentage, and the averaged multiple error (ME), considering six test images (shown by Figures 7 and 8). Close inspection reveals that the proposed method is able to achieve the highest success rate still keeping the smallest error and demanding less computational time and a lower number of function evaluations for all cases.Table 2
The averaged execution-time, detection rate, the averaged multiple error for the GA-based algorithm, the BFOA method, and the proposed APRE algorithm, considering six test images are shown by Figures8 and 9.
Performance indexes
Synthetic images
Natural images
(a)
(b)
(c)
(a)
(b)
(c)
GA
Averaged execution time
2.23
3.15
4.21
5.11
6.33
7.62
Averaged number of function evaluations
14,000
14,000
14,000
14,000
14,000
14,000
Success rate (DR) (%)
88
79
74
90
83
84
Averaged ME
0.41
0.51
0.48
0.45
0.81
0.92
BFOA
Averaged execution time
1.71
2.80
3.18
3.45
4.11
5.36
Averaged number of function evaluations
17,500
17,500
17,500
17,500
17,500
17,500
Success rate (DR) (%)
99
92
88
96
89
92
Averaged ME
0.33
0.37
0.41
0.41
0.77
0.37
APRE
Averaged execution time
0.21
0.36
0.20
1.10
1.61
1.95
Averaged number of function evaluations
2,321
2,756
3,191
4,251
3,768
3,834
Success rate (DR) (%)
100
100
100
100
100
100
Averaged ME
0.22
0.26
0.15
0.25
0.37
0.41Figure 7
Synthetic images and their detected circles for GA-based algorithm, the BFOA method, and the proposed APRE algorithm.Figure 8
Real-life images and their detected circles for GA-based algorithm, the BFOA method, and the proposed APRE algorithm.In order to statistically analyze the results in Table2, a nonparametric significance proof known as the Wilcoxon’s rank test [30–32] for 35 independent samples has been conducted. Such proof allows assessing result differences among two related methods. The analysis is performed considering a 5% significance level over the number of function evaluations and a multiple error (ME) data. Tables 3 and 4 report the P values produced by Wilcoxon’s test for a pairwise comparison of the number of function evaluations and the multiple error (ME), considering two groups gathered as APRE versus GA and APRE versus BFOA. As a null hypothesis, it is assumed that there is no difference between the values of the two algorithms. The alternative hypothesis considers an existent difference between the values of both approaches. All P values reported in Tables 3 and 4 are less than 0.05 (5% significance level) which is a strong evidence against the null hypothesis, indicating that the best APRE mean values for the performance are statistically significant which has not occurred by chance.Table 3
P values produced by Wilcoxon’s test comparing APRE to GA and BFOA over the averaged number of function evaluations from Table 2.
Image
P value
APRE versus GA
APRE versus BFOA
Synthetic images
(a)
3.3124
e
-
006
5.7628
e
-
006
(b)
5.3562
e
-
007
6.8354
e
-
007
(c)
4.1153
e
-
006
1.1246
e
-
005
Natural images
(a)
4.5724
e
-
006
4.5234
e
-
006
(b)
6.7186
e
-
006
5.3751
e
-
006
(c)
8.7691
e
-
007
6.2876
e
-
006Table 4
P values produced by Wilcoxon’s test comparing APRE to GA and BFOA over the averaged ME from Table 2.
Image
P value
APRE versus GA
APRE versus BFOA
Synthetic images
(a)
1.7345
e
-
004
1.5294
e
-
004
(b)
1.6721
e
-
004
1.4832
e
-
004
(c)
1.0463
e
-
004
1.9734
e
-
004
Natural images
(a)
1.5563
e
-
004
1.6451
e
-
004
(b)
1.2748
e
-
004
1.5621
e
-
004
(c)
1.0463
e
-
004
1.7213
e
-
004Figure9 demonstrates the relative performance of APRE in comparison with the RHT algorithm as it is described in [4]. All images belonging to the test are complicated and contain different noise conditions. The performance analysis is achieved by considering 35 different executions for each algorithm over the three images. The results, exhibited in Figure 9, present the median-run solution (when the runs were ranked according to their final ME value) obtained throughout the 35 runs. On the other hand, Table 5 reports the corresponding averaged execution time, detection rate (in %), and average multiple error (using (10)) for APRE and RHT algorithms over the set of images. Table 5 shows a decrease in performance of the RHT algorithm as noise conditions change. Yet the APRE algorithm holds its performance under the same circumstances.Table 5
Average time, detection rate, and averaged error for APRE and RHT, considering three test images.
Image
Average time
Success rate (DR) (%)
Average ME
RHT
APRE
RHT
APRE
RHT
APRE
(a)
7.82
0.20
100
100
0.19
0.12
(b)
8.65
0.12
64
100
0.47
0.11
(c)
10.65
0.15
11
100
1.21
0.13Figure 9
Relative performance of the RHT and the APRE.


## 5. Conclusions

In this paper, a novel evolutionary algorithm called the Adaptive Population with Reduced Evaluations (APRE) is introduced to solve the problem of circle detection. The proposed algorithm reduces the number of function evaluations through the use of two mechanisms: (1) adapting dynamically the size of the population and (2) incorporating a fitness calculation strategy which decides when it is feasible to calculate or only estimate new generated individuals.The algorithm begins with an initial population which will be used as a memory during the evolution process. To each memory element, it is assigned a normalized fitness value called quality factor that indicates the solution capacity provided by the element. From the memory, only a variable subset of elements is considered to be evolved. Like other population-based methods, the proposed algorithm generates new individuals considering two operators: exploration and exploitation. Such operations are applied to improve the quality of the solutions by (1) searching the unexplored solution space to identify promising areas containing better solutions than those found so far and (2) successive refinement of the best found solutions. Once the new individuals are generated, the memory is updated. In such stage, the new individuals compete against the memory elements to build the final memory configuration.In order to save computational time, the approach incorporates a fitness estimation strategy that decides which individuals can be estimated or actually evaluated. As a result, the approach can substantially reduce the number of function evaluations, yet preserving its good search capabilities. The proposed fitness calculation strategy estimates the fitness value of new individuals using memory elements located in neighboring positions that have been visited during the evolution process. In the strategy, those new individuals, close to a memory element whose quality factor is high, have a great probability to be evaluated by using the true objective function. Similarly, it is also evaluated those new particles lying in regions of the search space with no previous evaluations. The remaining search positions are estimated assigning them the same fitness value that the nearest location of the memory element. By the use of such fitness estimation method, the fitness value of only very few individuals are actually evaluated whereas the rest is just estimated.Different to other approaches that use an already existent EA as framework, the APRE method has been completely designed to substantially reduce the computational cost but preserving good search effectiveness.To detect the circular shapes, the detector is implemented by using the encoding of three pixels as candidate circles over the edge image. An objective function evaluates if such candidate circles are actually present in the edge image. Guided by the values of this objective function, the set of encoded candidate circles are evolved using the operators defined by APRE so that they can fit to the actual circles on the edge map of the image.In order to test the circle detection accuracy, a score function is used (19). It can objectively evaluate the mismatch between a manually detected circle and a machine-detected shape. We demonstrated that the APRE method outperforms both the evolutionary methods (GA and BFOA) and Hough Transform-based techniques (RHT) in terms of speed and accuracy, considering a statistically significant framework (Wilconxon test). Results show that the APRE algorithm is able to significantly reduce the computational overhead as a consequence of decrementing the number of function evaluations.



---

*Source: 868434-2013-10-31.xml*