solving incremental optimization problems via cooperative

This is a repository copy of Solving Incremental Optimization Problems via Cooperative Coevolution.

White Rose Research Online URL for this paper:http://eprints.whiterose.ac.uk/156226/

Version: Accepted Version

Article:

Cheng, R, Omidvar, MN orcid.org/0000-0003-1944-4624, Gandomi, AH et al. (3 more authors) (2019) Solving Incremental Optimization Problems via Cooperative Coevolution. IEEE Transactions on Evolutionary Computation, 23 (5). pp. 762-775. ISSN 1089-778X

https://doi.org/10.1109/TEVC.2018.2883599

© 2018 IEEE. Personal use of this material is permitted. Permission from IEEE must be obtained for all other uses, in any current or future media, including reprinting/republishing this material for advertising or promotional purposes, creating new collective works, for resale or redistribution to servers or lists, or reuse of any copyrighted component of this work in other works.

[email protected]://eprints.whiterose.ac.uk/

Reuse

Items deposited in White Rose Research Online are protected by copyright, with all rights reserved unless indicated otherwise. They may be downloaded and/or printed for private study, or other acts as permitted by national copyright laws. The publisher or other rights holders may allow further reproduction and re-use of the full text version. This is indicated by the licence information on the White Rose Research Online record for the item.

Takedown

If you consider content in White Rose Research Online to be in breach of UK law, please notify us by emailing [email protected] including the URL of the record and the reason for the withdrawal request.

mailto:[email protected]

https://eprints.whiterose.ac.uk/

IEEE TRANSACTIONS ON EVOLUTIONARY COMPUTATION, VOL. , NO. , MONTH YEAR 1

Solving Incremental Optimization Problems viaCooperative Coevolution

Ran Cheng, Mohammad Nabi Omidvar, Amir H. Gandomi, Bernhard Sendhoff, Stefan Menzel and XinYao, Fellow, IEEE

Abstract—Engineering designs can involve multiplestages, where at each stage, the design models are in-crementally modified and optimized. In contrast to tradi-tional dynamic optimization problems where the changesare caused by some objective factors, the changes in suchincremental optimization problems are usually caused by themodifications made by the decision makers during the designprocess. While existing work in the literature is mainlyfocused on traditional dynamic optimization, little researchhas been dedicated to solving such incremental optimizationproblems. In this work, we study how to adopt cooperativecoevolution to efficiently solve a specific type of incrementaloptimization problems, namely, those with increasing deci-sion variables. First, we present a benchmark function gener-ator on the basis of some basic formulations of incrementaloptimization problems with increasing decision variablesand exploitable modular structure. Then, we propose acontribution based cooperative coevolutionary frameworkcoupled with an incremental grouping method for dealingwith them. On one hand, the benchmark function generatoris capable of generating various benchmark functions withvarious characteristics. On the other hand, the proposedframework is promising in solving such problems in termsof both optimization accuracy and computational efficiency.In addition, the proposed method is further assessed usinga real-world application, i.e., the design optimization of astepped cantilever beam.

Index Terms—incremental optimization problem, coopera-tive coevolution, variable grouping, experience based opti-mization

I. INTRODUCTION

OPTIMIZATION problems are widely seen in vari-ous areas of science and engineering. Some of the

optimization problems have static objective functions,

Manuscript received –. This work was supported by two EPSRCgrants (Nos. EP/P005578/1 and No. EP/J017515/1). Xin Yao wassupported by a Royal Society Wolfson Research Merit Award andHonda Research Institute Europe. (The first two authors contributedequally to this work.)

Ran Cheng, Mohammad Nabi Omidvar and Xin Yao arewith the Center of Excellence for Research in ComputationalIntelligence and Applications (CERCIA), School of ComputerScience, University of Birmingham, Birmingham B15 2TT,U.K. (e-mail: [email protected], [email protected],[email protected]).

Amir H. Gandomi is with Analytics & Information Systems at Schoolof Business, Stevens Institute of Technology, Hoboken, NJ 07030, USA(email: [email protected]).

Bernhard Sendhoff and Stefan Menzel are with the Honda Re-search Institute Europe GmbH, Offenbach 63073, Germany. (e-mail:[email protected], [email protected])

Xin Yao (the corresponding author) is also with the Department ofComputer Science and Engineering, Southern University of Scienceand Technology, Shenzhen 518055, China.

whereas the others have dynamic objective functionschanging over time, known as the dynamic optimizationproblems (DOPs) [1]. Generally speaking, the changesin DOPs may affect the objective functions, the decisionvariables, or the constraints, where the reasons causingsuch changes can be attributed to the variance of avail-able resources, the arrival of new jobs, the environmentalchanges, etc [2]. For such DOPs, a widely acceptedassumption is that they must be solved online as timegoes by [3]. In other words, since the changes are causedby some objective factors, there are often some hardconstraints in computational time for each optimizationperiod.

While the changes in traditional DOPs are causedby some objective factors, there exist another kind ofoptimization problems with dynamic changes made bythe decision maker via incremental modifications. Ingeneral, the incremental modifications can be the ad-dition/removal of decision variables from the objectivefunction or the available constraints. For example, intruss topology optimization, the truss structures canbe incrementally optimized by adding nodes and barsinto the truss structure [4]; in aerodynamic shape opti-mization, the aerodynamic shape can be incrementallyoptimized by adding design parameters into the sim-ulation system [5], [6]. Such problems are incrementallymodified by adding decision variables. For simplicity, wedenote such problems as the incremental optimizationproblems (IOPs for short) hereafter.

Objective Function

Decision Maker

Final Solution

Modification Optimization

Fig. 1. Illustration to the optimization process of an incrementaloptimization problem with increasing decision variables

(IOP).

As illustrated in Fig. 1, solving an IOP often in-volves two iterative steps: optimization and modifica-tion, where the decision maker incrementally modifies


the objective function by adding more decision variables.At each design stage, the objective function is optimizedand its result is given back to the decision maker. Sub-sequently, the decision maker may change the designby modifying the objective function on the basis ofthe optimization results. This incremental optimizationprocess continues until the decision maker is satisfiedwith the final solution.

Broadly speaking, the IOPs can be seen as a specialtype of the time-linkage problems (DTPs), where thefuture behavior of a system is influenced by the decisionmade at each time stage [7], [8]. When solving DTPs, aproblem solver is expected to take the problem changesinto account and make corresponding predictions [9]. Inpractice, however, it is difficult to make such predictionsdue to the black-box nature of the problem. Even worse,an algorithm can be deceived to make wrong predictionscausing it to perform worse than the case where nopredictor is used [10]. Particularly, the modifications inIOPs are not likely to be predictable as they are made bythe decision makers according to personal preferences,which makes existing prediction-based approaches inef-fective in solving IOPs.

To solve an IOP, a naive approach is to iteratively re-run the optimizer once the objective function is modified.However, performing such iterative re-optimizations canbe time-consuming, especially when the function evalua-tions are computationally expensive [11]. Therefore, it isof particular interest to investigate ways of optimizingIOPs efficiently by saving redundant re-optimizations.Since the objective function of an IOP is incrementallydeveloped over several stages, intuitively, part of theresults obtained at each stage should be reusable infuture optimization attempts. This is due to the fact thatincremental modifications may not completely changethe original objective function, and such a special prop-erty is worth taking advantage of when solving IOPs.

From the experience-based optimization point ofview [12], the historical optimization results can beconsidered as useful experience to guide the optimiza-tion of IOPs at a later design stage. The key issuein experience-based optimization is how to make useof historical information to guide future optimization,either implicitly or explicitly. For example, Sushil Louisborrowed the idea from the case-based reasoning, wherethe previously obtained solutions are injected into thesearch process to improve the performance on syntac-tically similar problems [13]. This can be seen as animplicit way to use historical information.

In IOPs, the dependence between the newly addeddecision variables and the previous ones, namely, thevariable interactions, can be important information toguide future optimization. Despite that information suchas variables’ interaction pattern is not known a priori, for-tunately, the variable interaction techniques allow us toexplicitly extract valuable structural information about ablack-box problem and turn it into a gray-box one [14],[15]. Therefore, in this work, we propose to solve the

IOPs via cooperative coevolution (CC) [16], where thevariable interaction information is considered as theexperience acquired during the incremental optimizationprocess.

The CC framework was initially proposed to decom-pose the decision vector of an optimization probleminto a group of smaller components, thus breaking theoriginal optimization problem into a set of simpler ones.Since the decision vector of a given problem can bepartially nonseparable due to variable interactions, amajor challenge of using the CC framework is to finda proper decomposition. One classic method is knownas the random grouping [17]–[19], where the decisionvariables are randomly grouped into different groups,and thus the variable interactions are taken into con-sideration implicitly. By contrast, the other way is todetect the variable interactions in an explicit mannerand form the groups accordingly. As a representativemethod of such, differential grouping (DG) (as well as itsvariants) can identify the nonseparable (i.e. interacting)components with high accuracy [20], [21]. As reportedin the recent literature [22], such CC algorithms arepromising in solving partially separable problems.

By adopting the CC framework coupled with vari-able grouping, we propose to incrementally detect theinteractions between the incremental modifications andthe objective function of an IOP, such that the decisionvariables of an IOP can be incrementally grouped andoptimized. To be specific, the main contributions of thiswork are as follows.

1) Basic formulations of generic IOPs are presented.A generic IOP is defined as a single-objectiveoptimization problem (SOP) with several designstages, where at each stage, the objective function isincrementally modified by introducing additionaldecision variables into the objective function. Todescribe the incremental modifications in IOPs, wepresent three different modification types by con-sidering the interactions between added decisionvariables and those in the original problem.

2) A benchmark generator for IOPs is developed.In order to represent different modification typesin IOPs using benchmark functions, we proposea method based on the Givens rotation for con-trolling the variable interactions. On the basis ofthe proposed benchmark generator, we furtherinstantiate seven representative benchmark func-tions, which not only cover different modificationtypes but also have various properties in terms ofseparability and modality.

3) A contribution-based cooperative coevolution(CBCC) [23] framework is proposed forsolving IOPs. The proposed CBCC frameworkautomatically detects the interactions betweenthe newly added decision variables and thosein the original problem, thus determining whichdecision variables of the modified problem shouldremain unchanged and which should be re-


optimized. By considering the contributions of themodified parts and the unchanged parts, the CBCCframework adaptively allocates the computationalresources (i.e. fitness evaluations) to improve theoptimization efficiency.

The remainder of the paper is organized as follows.Section II covers the required background, including thefundamental concepts relating to variable interaction,and brief introductions to cooperative coevolution andvariable grouping. Section III presents the basic for-mulation of IOPs together with a benchmark functiongenerator. Section IV elaborates a contribution-based co-operative coevolutionary (CBCC) framework for solvingIOPs, and an incremental grouping (IG) algorithm forvariable interaction analysis and problem decomposi-tion. Section V presents the experimental results, whereseveral representative benchmark functions are gener-ated using the proposed generator, and the proposedCBCC method is assessed and compared with otherrepresentative algorithms on the benchmark functionsas well as a real-world engineering problem. Finally, thepaper is concluded in Section VI.

II. BACKGROUND

An incrementally modified optimization problem(IOP) can be referred to as a single-objective optimizationproblem (SOP) involving multiple design stages, wherethere are incremental decision variables added to the ob-jective function at each stage. Without loss of generality,an SOP1 can be defined as:

arg minx

f(x),

s.t. x ∈ X ,(1)

where X ⊂ RD is the decision space and x =

(x1, x2, ..., xD)⊤ ∈ X is the decision vector, and D is thenumber of decision variables.

In traditional single-objective optimization, a decisionvector can be optimized as a whole if the dimension isnot large, but when it comes to large-scale optimizationwhich can involve hundreds or even thousands of de-cision variables, the decision vector is usually decom-posed into a set of components to break a large-scaleproblem into a set of simpler subproblems [24], [25].Since such variable grouping techniques can be alsoapplied to solving IOPs, this section will present somerelated background knowledge, including the variableseparability as well as cooperative coevolution.

A. Variable Interaction

A decision variable xi is known as separable iff:

arg minx

f(x) =(

arg minxi

f(x), arg min∀xj,j 6=i

f(x))

, (2)

1This work only considers minimization problems with box con-straints.

Algorithm 1: (x⋆, f⋆) = CC(f )

1 /*Main Framework of CC*/2 P← randomized initial population;3 c← randomized initial context vector;4 //grouping stage5 G = Grouping(f);6 //optimization stage7 while Termination Condition is Not Satisfied do8 for κ = 1 to |G| do9 (P, c) = Optimizer(P, c, Gκ);

10 x⋆ = c ; f⋆ = f(x⋆) ;

11 return (x⋆, f⋆);

which means that there does not exist any other decisionvariable interacting with xi.

Based on the definition of separability, a problem f(x)is known as fully separable iff:

arg minx

f(x)=(

arg minx1

f(x1, . . . ), . . . , arg minxD

f(. . . , xD))

,

(3)where there does not exist any interaction between anypair of decision variables in x. By contrast, a problemf(x) is known as fully nonseparable if every pair ofdecision variables interact with each other.

However, if only part of the decision variables areseparable while the others are nonseparable, the problemis known as partially nonseparable:

arg minx

f(x)=(

arg minx1

f(x1, . . . ), . . . , arg minxm

f(. . . ,xm))

,

(4)where x1, . . . ,xm are disjoint sub-vectors of x, and 2 ≤m ≤ D. A problem is partially additively separable if:

f(x) =

m∑

i=1

fi(xi) , (5)

where xi are mutually exclusive decision vectors of fi,and m is the number of independent components.

B. Cooperative Coevolution

As shown in Algorithm 1, the main framework of co-operative coevolution (CC) consists of two main stages:the grouping stage and the optimization stage. In thegrouping stage, the whole decision vector is decomposedinto several components. At the grouping stage, thedecision variables are divided into a number of variablegroups, where the grouping information is stored in G.Ideally, each decision variable should only interact withother decision variables inside the same group, but notwith those in any other group. Such groups are alsoknown as the nonseparable (or interacting) groups. Inorder to determine the nonseparable groups, Omidvaret al. proposed the differential grouping (DG) methodon the basis of the following theorem [20]:

Theorem 1: Let f(x) be an additively separable func-tion. ∀a, b1 6= b2, δ ∈ R, δ 6= 0, if the following conditionholds

∆δ,xp[f ](x)|xp=a,xq=b1 6= ∆δ,xp

[f ](x)|xp=a,xq=b2 , (6)


then xp and xq are nonseparable, where

∆δ,xp[f ](x) = f(. . . , xp + δ, . . . )− f(. . . , xp, . . . ), (7)

refers to the forward difference of f with respect tovariable xp with interval δ.

The quantities in (6) are real-valued numbers; there-fore, the equality check cannot be evaluated exactly overthe floating-point number field on computer systems.Consequently, the equality check needs to be convertedto an inequality check by introducing a sensitivity pa-rameter: |∆(1) − ∆(2)| > ǫ, to check if two variablesare interacting. Here, ∆(1) and ∆(2) denote the left andright hand side of (6) respectively. In the absence ofrepresentation and roundoff errors, ǫ can be theoreticallyset to zero; however, this is not usually the case and theoptimal value of ǫ is often a nonzero positive number.This parameterization makes DG sensitive to choices of ǫwhose optimal value may vary from function to functionand difficult to tune by practitioners. To alleviate thisproblem, Omidvar et al. proposed DG2 [21], a parameter-free version of version of DG, which automatically sets ǫ

by estimating the bounds on the computational roundofferrors to maximize the accuracy of variable interactiondetection.

Using the variable grouping information, at the op-timization stage, the decision variables in each non-separable group (i.e. Gκ) are iteratively optimized in acoevolutionary manner, where the optimizer can be anyderivative-free single-objective optimization algorithm.Here the assumption is that the objective function isfixed, and the decomposition is valid throughout theoptimization process. However, this is not the case withIOPs, which results in a total failure of classic CC withthe existing decomposition methods. In this paper, wepropose a modified version of differential grouping,termed the incremental grouping (IG), which checksthe variable interaction pattern of the decision variablesadded at two neighboring stages during an incrementaldesign and optimization process. This allows for a moreinformed optimization of the modified problem basedon the solutions obtained prior to any modification ofthe objective function.

III. PROBLEM DEFINITION

A. Basic Formulations

An IOP can be formulated as a special SOP with T

number of design stages:

F = (f1(x1), ..., f t(xt), ..., fT (xT )), (8)

where t = 1, ..., T , and xt = (x1, x2, ..., xdt)⊤ ∈ R

dt

isthe decision vector having a size of dt at design staget. At each stage t ≥ 2, since the objective function ismodified by adding more decision variables, the size ofxt is increased as follows:

dt = dt−1 +∆dt, (9)

where ∆dt is the number of added decision variables atdesign stage t.

As xt is generated by adding more decision vari-

ables into xt−1, the objective function f t is also mod-

ified on the basis of f t−1. In practice, since differentmodifications can result in different interactions be-tween the added decision variables (denoted as ∆x

t =(xdt−1+1, xdt−1+2, ..., xdt)⊤) and the original decisionvariables xt−1, we consider the following three scenariosas possible modifications.

• Modification Type I: ∆xt do not interact with x

t−1. Inthis scenario, since none of the decision variables in∆x

t interacts with those in xt−1, the incremental de-

cision vector ∆xt can be optimized independently.

• Modification Type II: ∆xt partially interacts with x

t−1.In this scenario, only some of the decision variablesin ∆x

t interact with those in xt−1 and the rest are

independent.• Modification Type II: ∆x

t fully interact with xt−1. In

this scenario, since each decision variable in ∆xt

interacts with at least one decision variable in xt−1,

∆xt has to be optimized together with part of xt−1

inside the same variable groups.

Based on the above formulations, we further presenthow to design benchmark functions for IOPs in the nextsection.

B. Benchmark Function Generator

In benchmark function designs of SOPs, variable in-teraction (refer to Section II-A) is one of the most im-portant characteristics to be taken into consideration. Assuggested by the benchmark design principles in [25],while the separable functions can be simply generated byweighted aggregations of separable base functions (e.g.the Sphere function), the nonseparable functions shouldbe generated by rotating the fitness landscapes of somespecial base functions (e.g. the Elliptic function).

Moreover, since the separability properties are alsoclosely related to variable interactions, in order to coverthe three different modification types presented above,we adopt the following benchmark function generator:

F =

f1(x1) = g(R1(x1 − o1))

...f t(xt) = g(Rt(xt − o

t))...

fT (xT ) = g(RT (xT − oT ))

, (10)

where g is the base function scalable to the number ofdecision variables, ot is the shift vector determining thelocation of the global optimum of the variables added atstage t, and R

t is a rotation matrix that causes variableinteraction.

As an important property of IOPs, the objective func-tion f t (t ≥ 2) at each design stage is modified onthe basis of its previous version f t−1. To reflect such aproperty, both o

t and Rt can be incrementally modified


using iterative functions. These modifications are suchthat the location of the current optimal solution staysthe same while the interaction pattern of the variablesmay change. Therefore, o

t can be iteratively modifiedas:

ot =

[

ot−1

∆ot

]

, (11)

where t = 1, ..., T , ∆ot ∈ R

dt

is the optimal positionof the added decision variables. It is worth noting thatin this study we do not change the position of theglobal optimum over time. Neither the benchmark northe proposed framework limit the study of movingoptima within an incremental optimization context. Itis indeed possible to use the proposed framework forsuch a purpose; however, tracking optima is a matter ofcomponent optimizer rather than the framework itself.Therefore, to keep the focus of this study on the effectof adding variables on problem structure, we limit ourstudy to problems with fixed optima. It should be notedthat this does not necessarily mean a static landscape.Indeed the rotation of the landscape and the partialinteraction of the newly added decision variables withthe previous ones change the fitness of the previouslyobtained solutions. The focus of this study is to detectand respond to such changes rather than tracking op-tima.

In order to generate the rotation matrix Rt which

determines the variable interactions, there are severalbasic requirements to be satisfied. First, as a rotationmatrix, Rt must always be an orthogonal matrix with dtcolumn vectors. Second, as the number of dt increases(refer to (9)), the size of R

t should also increase cor-respondingly. Third, considering the three modificationtypes presented in Section III-A, Rt must be generatedby considering the variable interaction between any pairof decision variables. To this end, we propose a methodbased on the Givens rotation [26] for the incrementalmodifications of Rt.

Fig. 2. An illustrative example of the Givens rotation, where G12 =G(1, 2, π

4) and G23 = G(2, 3, π

4) are two rotation matrices generated

using Eq. (12) with D = 3.

Given two decision variables xi and xj , the xi-xj planecan be rotated by an angle of θ using the rotation matrixgenerated as:

G(i, j, θ) =

1 · · · 0 · · · 0 · · · 0...

. . ....

......

0 · · · cos θ · · · − sin θ · · · 0...

.... . .

......

0 · · · sin θ · · · cos θ · · · 0...

......

. . ....

0 · · · 0 · · · 0 · · · 1

D×D

, (12)

where cos θ and sin θ are at the intersections of the ithand jth rows and columns of an D-dimensional identitymatrix. As illustrated in Fig. 2, the Givens rotation isused to rotate the plane containing any two coordinateaxes (i.e. decision variables).

Now that the Givens rotation allows us to rotatethe plane containing any pair of coordinate axes, wecan control the variable interactions by generating therotation matrix correspondingly. Since the definition ofIOPs mandates an increase in the dimensionality of thedecision vector x

t, the rotation matrix Rt−1 must be

extended by adding ∆dt additional dimensions so thatits dimension conforms with that of xt:

Rt0 =

[

Rt−1

0

0 ∆It

]

, (13)

where ∆It is a ∆dt-dimensional identity matrix, such

that the original variable interactions reflected by Rt−1

stay unchanged. Then, we perform a series of Givensrotations on R

t0 to generate the new rotation matrix R

t:

Rt =

∏

p∈Pt,q∈Qt

G(p, q, θp,q)×Rt0, (14)

where Pt and Qt contain the indices of each pair ofinteracting decision variables, and the interaction degreeis controlled by the rotation angle θp,q. In this way, Rt

can be incrementally modified by specifying Pt, Qt andθp,q at each design stage t. To cover the three differentmodification types mentioned before, and to control theextent to which the new decision variables and theprevious ones interact, the sets Pt and Qt should bespecified as follows:

Pt ⊂ {dt−1 + 1, dt−1 + 2, ..., dt}, (15)

andQt ⊂ {1, 2, ..., dt−1}, (16)

with|Pt| = |Qt| = rt ×∆dt, (17)

where r ∈ [0, 1] is a parameter controlling the ratio ofthe new decision variables added at stage t that interactwith the previous ones.

Using the generators above, the benchmark functionscan be instantiated by specifying the following tuple:

(T, d1,∆dt, g, θp,q, rt), (18)


where d1 and ∆dt are the initial dimensionality andincremental dimensionality as defined in (9), g is the basefunction as defined in (10), θp,q is the rotation angle asdefined in (14), and rt is the interaction ratio as definedin (17). In Section V, we will instantiate some benchmarkfunctions using the proposed generator.

IV. METHOD

The prime challenge of solving IOPs is the efficienthandling of incremental modifications. A naive approachto dealing with such incremental modifications is to treatthe modified problem at each design stage as a com-pletely new one and opt for its re-optimization. How-ever, this can discard any useful information containedwithin the previously obtained solutions to a previousdesign formulation. It is clear that the extent to which theprevious solutions can be useful for the next formulationis dependent on the type of incremental modificationsit entails. As was mentioned in the previous section,variable interaction is an important factor determininghow the optimal value of each decision variable maychange through the addition of new variables. Indeed,in this context, it is precisely the variable interactionpattern of the newly added design variables with theprevious ones that cause the change. The aim of thissection is to propose a method for exploiting variableinteraction information for an efficient handling of in-cremental modifications.

In the absence of variable interaction information, itis difficult to devise an efficient strategy to deal withincremental modifications. The new variables are eithercompletely independent of the previous ones, or interactwith the previous ones in a partial or full manner (seeSec III). In a white-box problem full variable interactionpattern might be known; however, the complexity of theproblem or lack of an algebraic form for the objectivefunction can turn the problem into a black-box one.Variable interaction analysis allows us to extract valuablestructural information about the problem and turn it intogray-box optimization [14], [15]. For this purpose, wepropose a modified DG2 [21], termed the incrementalgrouping (IG) method, to suit IOPs. Further detailsabout variable interaction analysis are given later in thissection.

Once the variable interaction structure is inferred, itis natural to opt for a framework that facilitates theincorporation of such structural information. One suchframework is CC [16] which allows an optimizationproblem to be broken down into its constituent com-ponents and be optimized cooperatively in a round-robin fashion. This property is of great importance forsolving IOPs. CC not only allows us to preserve previoussolutions obtained for an earlier design, but also allowsfor a seamless transition to the next design stage bytreating new design variables as a new component. Theround-robin coordination policy of CC allows the newand old components to be optimized collaboratively.

A major drawback of traditional CC for solving IOPs,however, is its suboptimal component selection policy(i.e., the round-robin strategy). This policy distributesthe computational resources equally among componentswasting a considerable amount of resources when com-ponents have nonuniform contributions towards im-proving the overall solution quality [27]. Although theissue of imbalance has been studied in the general con-text of single objective optimization [28]–[31], its effect ismore pronounced when dealing with IOPs due to theirunique features:

• Non-uniform dimensionality of components: InIOPs, the decision variables added at each designstage can be treated as a separate component. Itis not uncommon to have a different number ofdecision variables added at each design stage. Thevariable interaction analysis may also result in com-ponents with different sizes depending on the un-derlying interaction pattern.

• Dynamics of the optimization process, and discrep-ancy among convergence behavior of components:First, due to the incremental nature of the designprocess in IOPs, the decision variables added atearlier design stages are often optimized longer. De-pending on their variable interaction pattern, someof the decision variables belonging to earlier designstages may converge to their optima not requir-ing further optimization, thus leading to marginalcontribution to the convergence of the objectivefunction at later design stages. Second, the newlyadded decision variables often have the highestcontribution, especially at the beginning of a designstage. Third, previously converged variables mayinteract with the ones added upon reformulation,which requires further optimization, thus leading toa transition from low to high contribution.

Contribution-based cooperative coevolution (CBCC)[23], [32] is an improved CC framework whose compo-nent selection policy is based on the contribution of com-ponents towards improving the overall solution quality,which makes CBCC a good fit for solving IOPs. It is clearthat CBCC requires an estimation for the contribution ofeach component, but due to the nature of the problem,the actual contribution of each component is not directlyobservable. For a partially separable problem, it is possi-ble to obtain a reliable estimation for the contribution ofa component by recording its improvement after a roundof optimization while keeping all other componentsconstant. As was mentioned previously, in this paper weconvert a black-box problem into a gray-box problem bymeans of variable interaction analysis, which allows usto minimize the inter-component dependence to obtainan accurate estimation of contributions.

The decomposition strategy that we devise in this pa-per is to analyze the interaction of the decision variablesadded at design stage t with respect to the previouscomponents formed by gradual analysis of the objective


Algorithm 2: Gt = IG(f t,Gt−1, dt−1, dt)

1 /*Pseudo Code of Incremental Grouping*/2 Θ← an uninitialized dt × dt interaction matrix;3 initialize Θt

ij ,∀i, j ∈ {1, . . . , dt−1} using Gt−1;

4 Θij = 1,∀i, j ∈ {dt−1 + 1, . . . , dt};5 for i = dt−1 + 1 to dt do6 for j = 1 to dt−1 do7 Θt

ij = InteractionDetection(f t, i, j);

8 Gt = ConnectedComponents(Θ) ;9 return Gt;

function at all previous design stages, i.e., 1, . . . , t− 1.

Algorithm 2 contains the details of the proposedincremental grouping (IG) method used in this paperto decompose IOPs. The algorithm takes as input f t

which is the objective function at design stage t, Gt−1

the previous decomposition used at stage t − 1, andthe dimensionality of the objective function at designstages t− 1 and t (i.e., dt−1 and dt respectively). In otherwords, the purpose of this procedure is to analyze thevariable interaction relationship of the decision variables({dt−1 + 1, . . . , dt}) with respect to all previous decisionvariables ({1, . . . , dt−1}) belonging to f t−1 and changethe problem decomposition accordingly.

To be specific, Algorithm 2 works by constructinga binary variable interaction matrix Θ which is thenprocessed as an adjacency matrix to form all the inde-pendent variable components. First, Θ is initialized torepresent Gt−1 which contains the decomposition priorto the design change. More specifically, Θij is set to oneif the ith and the jth decision variables belong to thesame component in Gt−1, and zero otherwise. If Gt−1 isan empty set, then all entries of Θ will be set to zero. Online 4, the entries of Θ that belong to the newly addeddecision variables are all set to one due to the nonsep-arability assumption mentioned previously. Then, in thenested loops, the interaction of all newly added decisionvariables ({dt−1+1, . . . , dt}) is checked against all previ-ous decision variables ({1, . . . , dt−1}). This is done usingthe InteractionDetection function, which returnsone if an interaction is detected and zero otherwise.The mechanism used in InteractionDetection isdirectly borrowed from the DG2 method [21], whichis based on the differential grouping theorem (Theo-rem 1). Finally, the connected components are detectedand returned by taking Θ as an adjacency matrix andprocessed using ConnectedComponents which is aclassic graph partitioning algorithm [33].

Algorithm 2 differs from its predecessor, namely, theDG2 method, in two major ways. First, it works pro-gressively during the course of optimization and is in-voked every time the problem formulation is changed bythe inclusion of new decision variables to the objectivefunction. Second, instead of performing a full pair-wiseanalysis of the decision variables, it only analyzes thenew decision variables with respect to the previous ones,

Algorithm 3: (x⋆, f⋆) = CBCC(F, pe)

1 /*Main Framework of the proposed CBCC*/2 t = 1;3 Gt =

{

{1, . . . , dt}}

;4 P

t ← randomized initial population;5 c

t ← randomized initial context vector;6 ∆

t ← component contributions initialized to ∞;7 f t

c = f t(ct);8 while the termination criteria is not reached do9 κ = ComponentSelector(∆t);

10 while κ is the best component according to ∆t do

11 //optimization12 (Pt, ct) = Optimizer(Pt, ct,Gtκ);13 //contribution calculation14 f t

p = f tc ; f

tc = f t(ct); ∆κ = f t

p − f tc ;

15 if rand() < pe then16 ∆i =∞,∀i ∈ {1, . . . , |G|} ;

17 //new design stage18 if F has switched to a new design stage then19 t = t+ 1;20 Gt = IG(f t,Gt−1, dt−1, dt);21 P

t ← extending Pt−1 to match dt;

22 ct ← extending c

t−1 to match dt;23 ∆

t ← extending ∆t−1 to match |Gt|;

24 x⋆ ← c

t ; f⋆ ← f t(x⋆) ;25 return (x⋆, f⋆);

which makes it faster than DG2. To be exact, for transi-tions t ∈ {2, · · · , T }, Algorithm 2 requires ∆dt(dt−1 + 1)evaluations whenever the design is changed by adding∆dt new decision variables to the objective function.Additionally, it requires d1 extra evaluations for the firsttransition (t = 1 → t = 2).

As mentioned previously, the incremental groupingmethod denoted by Algorithm 2 is invoked repeatedlywithin the CBCC framework at the beginning of eachnew design stage to find how the newly added decisionvariables interact with the previous ones, such thatthe results obtained from the previous stages can bereused in the new stage. In this paper, we modify theframework in [32] as our proposed CBCC framework forsolving IOPs, where the details are given in Algorithm 3.The proposed CBCC framework differs from its originalversion in the following ways. First, all its components(i.e. Gt, P

t, ct, ∆

t) are modified to be extendable tosuit IOPs. Second, the component selection policy of theproposed algorithm is improved to maintain a betterexploration/exploitation balance. Third, the use of pe ismodified such that when it is set to 1 it acts like canonicalCC and when set to 0 it becomes a greedy algorithm.Finally, the IG method is iteratively invoked duringthe incremental optimization process. To be specific, theproposed CBCC framework takes as input the objectivefunction F following the notation used in (8) and theparameter pe which determines the extent to which thealgorithm optimizes the most contributing component ina greedy manner (exploitation) or allows all componentsto get a chance to update their contribution (exploration).


On lines 2-7 of Algorithm 3, the framework is initial-ized. Similar to Algorithm 2, Gt on line 3 is a set of setsdefining how the problem should be decomposed. Inthe first design stage (t = 1), the objective function (f1)is assumed to be fully nonseparable; therefore, the onlycomponent that the algorithm begins with is {1, . . . , d1},where d1 is the dimensionality of f1. The vector ∆

t

records the latest contribution of all components to theconvergence of f t at each design stage. Therefore, thesize of ∆t is equal to the cardinality of Gt. As can be seen,the contributions are initialized to infinity to guaranteethat all components are optimized at least once. It isclear that the contributions will be updated in the mainloop (lines 8-23) whenever a component is selected foroptimization.

The CBCC framework works by finding the com-ponent with the largest contribution (κ). This is doneusing the ComponentSelector function which simplyreturns the index of the component with maximumcontribution value to the convergence of f t accordingto ∆

t. The selected component is optimized while itscontribution is larger than all other components (line10). The Optimizer function is any optimizer of choicewhich optimizes the component κ for a certain numberof iterations. Once the component κ is optimized, itscontribution is updated and set to the magnitude ofimprovement before and after optimization (lines 12-14).This exploitation strategy is broken with probability peto give all components a chance to be optimized, whichis done by setting the contribution of all components to∞.

Whenever the IOP is switched to a new design stage,the IG function is invoked to analyze the relationshipbetween the new decision variables and the previousones. Correspondingly, the dimensionality of Pt, ct, and∆

t are updated to match the dimensionality of f t andthe most recent number of components. It is clear that thenew decision variables added to each candidate solutionare initialized within the respective bounds for eachdimension, and the new decision variables on the contextvector are also initialized in a similar manner. Finally,the dimensionality of ∆

t is changed to match the newcardinality of Gt while preserving the contribution ofprevious components and initializing the new ones to ∞.The above procedure is repeated until the design processof the given IOP is finalized and the termination criteriaare reached.

V. EXPERIMENTAL STUDY

In this section, we will conduct a series of experimentsto assess the performance of the proposed CBCC frame-work for solving IOPs. First, we will instantiate sometest functions using the benchmark function generatorproposed in Section III-B. Second, we will perform someempirical comparisons using the instances of the bench-mark functions. Finally, the proposed CBCC frameworkis further assessed using a real-world application, i.e.,the design optimization of a stepped cantilever beam.

A. Benchmark Functions

As summarized in Table S-I in the supplementarydocument, we have instantiated seven benchmark func-tions using the benchmark generator as given in Sec-tion III-B. The four base functions are selected amongthe most commonly used ones in benchmark functiondesigns [25], [34], [35]. More importantly, all of the fourfunctions are originally separable but become nonsep-arable after landscape rotations [36], which meets therequirement as mentioned in Section III-B. For simplic-ity, the rotation angles θp,q are all randomized within(0, π2 ), and the number of design phases T is set to3 for all instances. The benchmark functions presentedin Table S-I in the supplementary document cover thethree modification types described in Section III-A, eachexhibiting various modality and separability features. Inwhat follows, we explain how these functions fit into thethree modification types.

1) Modification Type I: For IOPs with ModificationType I (e.g. F1 and F2), the incremental modifications willnot affect the variable interactions in the original prob-lem. In this case, the optimum of the original problemis fully reusable at the new design stage. To be specific,we consider the following two scenarios:

• Fig. 3(a) shows a case where the new decisionvariables added at the latest design stage do notinteract with each other or with any of the variablesfrom previous stages. This means that each variablecan be optimized independently;

• Fig. 3(b) shows a case where the decision variablesadded at the latest stage are fully nonseparable,while having no interaction with any of the vari-ables from previous stages. This means that thenew variables can be treated as a nonseparablecomponent and be optimized independently of theother variables.

2) Modification Type II: For IOPs with ModificationType II (e.g. F1 to F6), the incremental modifications willpartially affect the variable interactions in the originalproblem. In this case, the optimum of the original prob-lem is only partially reusable at the new design stage. Tobe specific, we consider the following three scenarios:

• As shown in Fig. 3(c), the problem is initialized witha relatively large number of decision variables butmodified with small increments;

• As shown in Fig. 3(d), the problem is initialized witha relatively small number of decision variables, butmodified with big increments;

• As shown in Fig. 3(e), the problem is initialized andmodified with even scales.

3) Modification Type III: As shown in Fig. 3(f), forIOPs with Modification Type III (e.g. F7), the incremen-tal modifications will completely change the variableinteractions in the original problem. In this case, theproblem is fully changed and thus has to be completelyre-optimized.


0 10 20 30 40 50 60

i

0

10

20

30

40

50

60

j

xi interacts with xj

(a) Modification Type I (F1)

0 10 20 30 40 50 60

i

0

10

20

30

40

50

60

j


(b) Modification Type I (F2)

0 10 20 30 40 50 60

i

0

10

20

30

40

50

60

j


(c) Modification Type II (F3)

0 10 20 30 40 50 60

i

0

10

20

30

40

50

60

j


(d) Modification Type II (F4)

0 10 20 30 40 50 60

i

0

10

20

30

40

50

60

j


(e) Modification Type II (F5 or F6)

0 10 20 30 40 50 60

i

0

10

20

30

40

50

60

j


(f) Modification Type III (F7)

Fig. 3. Variable interactions of IOPs with different modification types.Different design stages are marked by the dashed lines.

B. Empirical Comparisons

Using the benchmark functions as given in the previ-ous subsection, this subsection presents some empiricalcomparisons to demonstrate the effectiveness of the pro-posed CBCC method. To begin with, we first introducethe methods in comparison. Then, the empirical compar-isons mainly consist of two parts. First, we assess thegeneral performance of CBCC on the benchmark func-tions given a specific number of fitness evaluations as thetermination condition. Second, we further investigate theconvergence speed of CBCC by setting specific accuracylevels.

1) Methods in comparison: In addition to the proposedCBCC method, we use three other methods to conductthe empirical comparisons, including the original CCmethod, an incremental method, and a naive method:

• The CC method: The classic CC framework as given

by Algorithm 1 is adopted, where each incrementalcomponent is considered as an independent variablegroup. Here all components are optimized equallyin a round-robin fashion.

• The incremental (INC) method: Each incrementalcomponent is optimized completely independently.Once the problem is modified, the method automat-ically switches to the new optimization stage andmerely focuses on the newly added component.

• The naive method: As indicated by its name, thismethod simply treats the modified problem as anew one and performs a complete re-optimizationof the modified problem.

In order to deal with the incrementally increased scalesof IOPs, the decision vectors in each method are alsoincrementally increased. The component optimizer usedby all methods mentioned above is SaNSDE [37]. For faircomparisons, the random seed of the random generatorin SaNDE is set to the same value in each method, suchthat SaNDE performs the same stochastic behaviors. Thepopulation size of SaNDE is set to 50, and it is runfor 50 iterations on any component upon selection. Inpractice, any other problem-specific optimizer is alsoapplicable. For example, if the problem exhibits otherforms of dynamism such as moving optima, dynamic op-timization algorithms capable of tracking optima, suchas multi-population methods [1], can be used as thecomponent optimizer. For the proposed CBCC method,the parameter pe is set to 0.2 in all the experiments, andthe sensitivity analysis of pe can be found in Section S-IIin the supplementary document.

2) General Performance: To assess the general perfor-mance of the proposed CBCC method, we conduct someempirical comparisons with the CC method, the INCmethod, and the Naive method on the seven benchmarkfunctions (F1 to F7). To obtain statistical results, eachmethod is run for 31 independent times on each testfunction. For each run, we use a maximum number of5000D fitness evaluations (FEs) as the final terminationcondition and assume that the decision-maker will makemodifications on the given IOP once a number of 5000dtFEs is reached at each stage. In this way, a fixed numberof FEs is used by each method at each stage, and thusguaranteeing the fairness of the comparisons.

Table I2 contains the experimental results for assessingthe performance of CBCC in comparison with the threemethods mentioned above. At the initial stage (i.e. Stage1), the four methods have obtained exactly the sameresults on each test function. This is due to the fact thatwe have set the random seed of the random generatorto the same value for the SaNSDE optimizer adoptedin each method. However, as the test functions areincrementally modified at later stages (i.e. Stage 2 andStage 3), the proposed CBCC method shows significantlybetter general performance than the other three methods.

2A complete table containing other descriptive statistics is given inTable S-III in the supplementary document.


TABLE ITHE STATISTICAL RESULTS OF OPTIMIZATION ERRORS OBTAINED BY

THE CBCC, CC, INCREMENTAL (INC) AND NAIVE METHODS ON THE

BENCHMARK TEST FUNCTIONS. MEDIANS BASED ON 31 INDEPENDENT

RUNS. BEST MEDIAN RESULTS ARE HIGHLIGHTED.

Stage 1 Stage 2 Stage 3

Fun. All Algs. CBCC CC INC Naive CBCC CC INC Naive

F1 0.00e0 0.00e0 1.66e-18↑ 0.00e0≈ 6.98e-26↑ 4.45e-28 3.51e-11↑ 0.00e0↓ 5.99e-15↑

F2 2.48e1 5.39e1 5.94e1↑ 4.81e1 ↓ 1.70e2↑ 8.48e1 1.07e2↑ 7.27e1↓ 3.60e2↑

F3 1.69e5 2.25e4 6.26e4↑ 7.11e4↑ 6.68e4↑ 7.38e3 2.65e4↑ 5.61e4↑ 8.26e4↑

F4 1.30e0 1.76e1 1.66e2↑ 2.03e2↑ 3.14e1↑ 1.25e2 1.04e3↑ 1.20e3↑ 2.71e2↑

F5 3.49e4 5.42e3 7.17e4↑ 2.09e4↑ 1.94e4↑ 1.77e0 3.01e4↑ 1.86e4↑ 1.45e3↑

F6 2.48e1 1.10e2 1.08e2≈ 9.15e1 ↓ 1.71e2↑ 1.56e2 1.73e2↑ 1.58e2≈ 3.43e2↑

F7 1.37e0 3.14e1 3.14e1≈ 4.13e3↑ 3.14e1≈ 5.12e1 5.22e1↑ 3.03e3↑ 5.58e1↑

w/t/l — 5/2/0 4/1/2 6/1/0 — 7/0/0 4/1/2 7/0/0

The Wilcoxon signed-rank test at significance level of 5% is performed to compare the resultsobtained by the CBCC method and the others.↑, ≈and ↓ : CBCC performs statistically significantly better, equal and worse.w/t/l: The number of results where CBCC statistically wins/ties/loses in the comparisonswith other methods.Hilighted entires are significantly better than the rest based on multiple comparison withHolm p-value correction.

0 20 40 60 80 100 120

Generation

1

2

3

Com

ponent

(a) CC

0 20 40 60 80 100 120

Generation

1

2

3

Com

ponent

(b) INC

Fig. 4. Components selected by CC and INC to undergo optimizationat different stages of the incremental design process.

For F1 and F2, the proposed CBCC outperforms theCC and Naive methods, but is outperformed by theINC method. In this scenario, the decision variables ineach incremental component can be naturally optimizedindependently, while the incremental grouping in CBCCwill spend some extra function evaluations on variableinteraction detections, thus reducing the total FEs usedfor optimization. By contrast, the INC method directlyconsiders each incremental component to be indepen-dent, which is coincidentally consistent with the idealgrouping.

Given the fact that both CC and INC methods adoptthe same grouping strategy, an interesting observationis that the INC method still significantly outperformsthe CC method. On problems with Modification TypeI (F1 and F2), the incremental components are of equalimportance; therefore, the strategy adopted by INC is themost efficient due to an overall even allocation of FEsupon termination of the algorithm. CC, however, givesan equal chance to all components available at staget, which results in an uneven resource allocation witha bias towards giving more resources to components

belonging to earlier design stages. This observation canbe further confirmed by Fig. 4, where the CC methoditeratively switches between the three incremental com-ponents, but the INC method merely focuses on theincremental component at each stage.

For F3 to F6, the proposed CBCC method significantlyoutperforms the other three methods. The advantages ofCBCC mainly lie in two aspects. First, CBCC performsincremental variable grouping to determine if the newlyadded decision variables interact with the previous ones,such that the nonseparable variable groups can be opti-mized in a cooperative manner. Second, CBCC performsadaptive allocation of the FEs to different nonseparablevariable groups, such that the decision variables makingmore contributions to the convergence of the objectivefunction (e.g. the newly added decision variables ateach stage) will have a higher priority to be optimized.By contrast, none of the other three methods is ableto handle the incremental modifications in F3 to F6properly.

Finally, for the fully nonseparable function F7, the INCmethod is significantly outperformed by the other threemethods. It is interesting to see that the performanceof the INC method on F7 is exactly opposite to itsperformance on F1 and F2. This is due to the fact thatthe INC method consistently considers each incrementalcomponent to be independent, while F7 happens to bea fully nonseparable function. In fact, regardless of thevariable interactions between the incremental compo-nents, the CC and INC methods always adopt the samegrouping strategies on all of the seven test functions asdemonstrated in Fig. 4. This indicates that the CC andINC methods lack robustness or generality when appliedto different problems.

By contrast, as evidenced by Fig. 5, the proposedCBCC method shows robust performance on varioustypes of problems by adaptively grouping the decisionvariables and allocating the FEs. To be specific, for fullyseparable problems, the CBCC method uniformly allo-cates the FEs to the optimization of three variable groups(Fig. 5(a)); for problems with a large initial componentand small incremental components, the CBCC methodmainly focuses on the first variable group (Fig. 5(b));for problems with a small initial component and largeincremental components, the CBCC method mainly fo-cuses on the second and third variable groups (Fig. 5(c));and for fully nonseparable problems (Fig. 5(d)), CBCC’sperformance is similar to that of the Naive method. Itshould be noted that CBCC has an advantage over theNaive method even on a fully nonseparable problembecause it does not completely re-initialize the solutionsobtained prior to a change, while the Naive methodcompletely re-optimizes the problem after a change. Thisis also evident from Table I. Finally, the convergenceprofiles in Fig. S-1 in the supplementary document alsoindicate the robust performance of CBCC on various testfunctions.

It should be noted that CBCC uses the incremental


0 20 40 60 80 100 120

Generation

1

2

3

Gro

up

(a) F1

0 20 40 60 80 100 120

Generation

1

2

3

Gro

up

(b) F3

0 20 40 60 80 100 120

Generation

1

2

3

Gro

up

(c) F4

0 20 40 60 80 100 120

Generation

1

2

3

Gro

up

(d) F7

Fig. 5. Components selected by CBCC to undergo optimization at different stages of the incremental design process.

TABLE IITHE ACCURACY LEVELS FOR TEST FUNCTIONS F1 TO F7.

Function F1 F2 F3 F4 F5 F6 F7

Accuracy Level 10−10

102

104

102

104

104

104

grouping (IG) method presented in the previous section.Since the focus of this work is on analyzing the effect ofan incremental design process, we limited our study toIG which analyzes the interaction of the newly addeddecision variables with respect to the previous onesfrom an earlier stage. One could easily opt to analyzethe internal structure of a component at the expense ofsome additional computational cost. However, findingthe optimal decomposition of a component is beyondthe scope of this work. For the sake of completeness,we included some preliminary results in the supple-mentary material to compare the two strategies. Theresults in Table S-IV suggest that the two strategiesperform statistically similar on small- to medium-scaleproblems with IG having a slight advantage. Given thecomputational advantage of IG over DG, we expect thegap to become wider on large-scale problems. In whatfollows, we will investigate the convergence speed ofCBCC by conducting additional experiments.

3) Convergence Speed: In practice, the decision-makermay not make incremental modifications to an IOPuntil the optimization results are satisfactory at a certaindesign stage. Therefore, the convergence speed (in termsof FEs) can be an important criterion when solving IOPs.In order to assess the convergence speed of the proposedCBCC method, we conduct additional experiments asgiven next.

First, we define some accuracy levels for each testfunction as listed in Table II. We assume that, duringthe optimization process, it is automatically switchedto the next stage once the accuracy level is reached.We still run each method for 31 independent times andrecord the success rate (SR) and computational cost withrespect to the accuracy levels. In order to guaranteethat there is sufficient FEs for each method to reach the

TABLE IIITHE MEAN RESULTS OF THE SUCCESS RATE (SR) AND

COMPUTATIONAL COST OF THE CBCC, CC, INCREMENTAL (INC) AND

NAIVE METHODS ON THE BENCHMARK TEST FUNCTIONS. BEST

RESULTS ARE HIGHLIGHTED.

Stage 1 Stage 2 Stage 3

Fun. Stats. All Algs. CBCC CC INC Naive CBCC CC INC Naive

F1Cost 3.31e+4 7.24e+4 9.75e+4 6.76e+4 8.35e+4 1.19e+5 1.94e+5 1.03e+5 1.62e+5SR 100% 100% 100% 100% 100% 100% 100% 100% 100%







SR: The success rate calculated by SR = NSRNR

, where NR denotes the total number ofruns and NRS denotes the number successful runs having reached the predefined accuracylevels.Cost: The minimum number of FEs cost by each method to reach the predefined accuracylevels.Highlighted entires are significantly better based on a series of Wilcoxon signed-rank testswith Holm p-value adjustment.

accuracy levels, we set the maximum number of FEsto 50000dt (10 times as large as what was used in theprevious experiment) for each stage. If the maximumnumber of FEs is exceeded, the optimization process willautomatically switch to the next stage.

As demonstrated by the results summarized in Ta-ble III, CBCC generally achieves the best overall per-formance in terms of convergence speed. At Stage 1,all four methods obtained the same results due to thesame random seed used in the SaNSDE optimizer. AtStage 2 and Stage 3, the advantage of CBCC start toemerge, resulting in a high success rate and a lowercomputational cost. An interesting observation is thatINC is also outperformed by CBCC on the multimodalfunction F2 in terms of the success rate. This is dueto the fact that CBCC has a good chance to escapefrom local optima when switching between different


F1 F2 F3 F4 F5 F6 F7

Test Function

0

0.5

1

1.5

2

2.5

3C

ost (M

inim

um

FE

s)

106

CBCC

CC

INC

Naive

Fig. 6. Average computational costs needed by each method to reachthe predefined accuracy levels at the end of the final optimization stage(Stage 3).

variable groups, while INC is unable to improve thesolution quality once trapped in local optima, even ifa large number of FEs are given. As further evidencedby Fig. 6, CBCC shows clear advantages over the otherthree methods on the difficult multimodal functions F2,F4, F6, and F7 by reaching the designated accuracy levelswith fewer evaluations. By contrast, the four methodsshow similar convergence speed on unimodal functionssuch as F1, F3, and F5. This indicates the better potentialof CBCC in dealing with complicated problems withlimited computational costs.

C. Design Optimization of a Stepped Cantilever Beam

In this section, we investigate the efficacy of the pro-posed algorithm on a structural engineering problem.The case study is about the design of a stepped cantileverbeam [38], which has applications in aeronautical engi-neering for rotor shaft design, in mechanical engineeringfor designing robot arms, and in civil engineering forbeam design. The objective is to minimize the weight ofthe beam such that it is capable of bearing a concentratedload at its end while satisfying a set of mechanical con-straints. The cantilever beam comprises a set of segmentseach having a variable cross-section area defined by aradius (ri) and its length (li) (Fig. 7). This is a scalabledesign problem whose granularity can be adjusted byallowing the total number of segments to change in aniterative design process. The objective function of thisproblem is defined as follows:

min f(r, l) = ρ

n∑

i=1

liπr2i , (19)

where ρ is the density, li is the length of the ith segment,and ri is the radius of the ith cross-section area.

This problem must satisfy a series of stress constraintssuch that the bending stress in each beam segment (σi)must be less than a predefined allowable stress (σa).

Fig. 7. Schematic of the stepped beam design problem with circularsections.

1 2 3 4 5 6 7 8 9 10

1

2

3

4

5

6

7

8

9

10

(a) 10D

2 4 6 8 10 12 14 16 18 20

2

4

6

8

10

12

14

16

18

20

(b) 20D

5 10 15 20 25 30

5

10

15

20

25

30

(c) 30D

Fig. 8. Variable interaction structures of the 10, 20 and 30-dimensionalcantilever beam problems.

Therefore, the solutions should also satisfy the followingn nonlinear constraints:

gi(ri) =σi

σa

− 1 ≤ 0, (20)

where,

σi =Miri

Ii, (21)

Mi = F (L+ (1− i)li), (22)

Ii = πr4i4, (23)

and L is the total length of the beam, F the concentratedforce at its end, and Ii the moment of inertia of theith segment. To satisfy the stress constraints, we useda penalty function approach to penalize the infeasiblesolutions.

In addition to the above, the physics of the problemalso mandates that the segments closer to the fixed endhave a larger cross-section, i.e., r1 ≥ r2 ≥ · · · ≥ rn(see Fig. 7). This is due to the fabrication conditionand the fact that a more distant load causes a largerbending stress. To satisfy this condition, the objective isreformulated such that the radius of each segment, withthe exception of the first segment, is defined with respectto its adjacent segment closer to the restraining wall.

ri = r1

i−1∏

j=1

pj, for i ∈ {2, . . . , n}, (24)

where 0 < r1 ≤ 30, and 0 < pj ≤ 1. For this particularexperiment, we set L = 500 (cm), σa = 14000 (N/cm2),and the concentrated force F = 50000 (N). It is alsocustomary in structural design to assume l1 = · · · = ln =Ln

. Therefore, the final objective function will have thefollowing form f(r1, p1, . . . , pn−1).

To compare the performance of the algorithms, thecantilever beam problem is solved incrementally startingwith 10 segments in the first design stage. The design


TABLE IVPERFORMANCE OF CBCC, CC, INC, AND NAIVE ALGORITHMS ON A

CANTILEVER BEAM WITH CIRCULAR CROSS-SECTIONS.

Fun. Stats. CBCC CC INC Naive

Stage 1Median 1.94e+05 1.94e+05 1.94e+05 1.94e+05Mean 1.95e+05 1.95e+05 1.95e+05 1.95e+05StDev 5.10e+03 5.10e+03 5.10e+03 5.10e+03Feasible (%) 100% 100% 100% 100%



Highlighted entires are significantly better based on a series of Wilcoxon signed-rank testswith Holm p-value adjustment.The values are based on the penalized values of the objective function.

is subsequently refined by increasing the number ofsegments to 20 and 30 in the second and the thirdstages respectively. In other words, d1 = 10, d2 = 20,and d3 = 30. The variable interaction analysis us-ing DG2 shows that the cantilever beam has a par-tially separable objective function with the first 5 vari-ables having interactions, while all other variables aredetected to be separable (Fig. 8). Therefore, the fi-nal decomposition for CBCC and CC is as followsG1 = {{1, . . . , 10}},G2 = {{1, . . . , 10}, {11, . . . , 20}},G3 ={{1, . . . , 10}, {11, . . . , 20}, {21, . . . , 30}}. Similar to otherexperiments in this paper, the population size is set to 50.To test if the compared methods are able to perform fastconvergence, the maximum number of objective functionevaluations is set to 500D, and the increments occur atevery 500dt evaluations.

The experimental results for the CBCC, CC, INC, andNaive algorithms are given in Table IV. The results arebased on 31 independent runs and the highlighted en-tries are statistically significant using a series of Wilcoxonsigned-rank tests with Holm p-value correction basedon a 95% confidence interval. As can be seen, CBCCoutperforms all other algorithms at the end of the secondand the third stages.

The table also contains the percentage of feasiblesolutions for each algorithm. The cantilever beam prob-lem has a very small feasible region. A Monte Carlosimulation using 1e9 sample points results in only 318feasible solutions to be sampled randomly for a 10-dimensional version of the problem. The number ofrandomly sampled feasible solutions for the 20- and 30-dimensional cases drops to zero. The results in Table IVclearly shows the benefit of using an incremental ap-proach for solving such highly constrained problem. Ascan be seen, all algorithms have a 100% success rateat the first stage. However, at the second and thirdstages, the performance of INC and Naive algorithmsdeteriorate significantly resulting in almost no feasiblesolution being found by the two algorithms. By contrast,CBCC and CC have a 100% success rate across all

0 100 200 300

Generation

105

1010

1015

1020

Fitness

CBCC

CC

INC

Naive

Fig. 9. The convergence profile of each method applied to the real-world application problem.

stages. Although INC also optimizes the problem in anincremental manner, its greedy nature does not allow theprevious components to be optimized after an increment.

As indicated by Fig 9, CBCC and CC show similar con-vergence speed; by contrast, INC and Naive completelyfail to converge at the second and third stages.

VI. CONCLUSIONS

In this work, we have investigated how to efficientlysolve a specific type of IOPs with increasing decisionvariables. First, we have represented some basic formu-lations of IOPs. Then, on the basis of the basic formula-tions, we designed a benchmark function generator forgenerating benchmark functions of IOPs. By taking thespecial property of IOPs, we have proposed a contri-bution based cooperative coevolution (CBCC) method.As part of the CBCC method, an incremental grouping(IG) method has also been proposed to deal with theincremental modifications.

As experimental studies, we assessed both the bench-mark function generator and the proposed CBCCmethod. To cover different types of incremental mod-ifications as given in the basic formulations of IOPs,we generated seven benchmark functions using the pro-posed generator. Using the seven benchmark functions,we have also conducted some experimental comparisonsbetween the proposed CBCC method and three othertypical methods. Our experimental results have demon-strated the robust performance of the proposed CBCCmethod. Furthermore, the performance of the proposedCBCC method has also been assessed on a real-worldapplication.

As pointed out in the introduction, this work fallsinto the general scope of the experience-based opti-mization [12], where the motivation is to use the ex-perience acquired in historical design stages to guidefuture optimization. As a specific instance, we haveconsidered the variable interaction information as theimportant experience in solving IOPs, and we have


adopted the CC framework as the solver to make use ofsuch experiences. In the future, we would like to furtherimprove the efficiency of the proposed CBCC frameworkand the IG method in terms of the cost of functionevaluations, which can be particularly meaningful whendealing with computationally expensive IOPs. It is alsoworth noting that the IOPs studied in this work is justone of the many possible scenarios where incrementalmodifications are made. Real-world problems could alsoinvolve incrementally added constraints, and solvingsuch problems may require specially tailored constrainthandling methods.

REFERENCES

[1] T. T. Nguyen, S. Yang, and J. Branke, “Evolutionary dynamic opti-mization: A survey of the state of the art,” Swarm and EvolutionaryComputation, vol. 6, pp. 1–24, 2012.

[2] S. Yang, Y.-S. Ong, and Y. Jin, Eds., Evolutionary computation indynamic and uncertain environments, ser. Studies in ComputationalIntelligence. Springer, 2007, vol. 51.

[3] P. Bosman, “Learning and anticipation in online dynamic op-timization,” Evolutionary computation in dynamic and uncertainenvironments, pp. 129–152, 2007.

[4] I. Y. Kim and O. De Weck, “Variable chromosome length geneticalgorithm for progressive refinement in topology optimization,”Structural and Multidisciplinary Optimization, vol. 29, no. 6, pp. 445–456, 2005.

[5] M. Olhofer, Y. Jin, and B. Sendhoff, “Adaptive encoding foraerodynamic shape optimization using evolution strategies,” inProc. of IEEE Congress on Evolutionary Computation, vol. 1. IEEE,2001, pp. 576–583.

[6] Y. Jin, M. Olhofer, and B. Sendhoff, “On evolutionary optimiza-tion of large problems using small populations,” in InternationalConference on Natural Computation. Springer, 2005, pp. 1145–1154.

[7] J. Branke and D. C. Mattfeld, “Anticipation and flexibility indynamic scheduling,” International Journal of Production Research,vol. 43, no. 15, pp. 3103–3129, 2005.

[8] T. T. Nguyen and X. Yao, “Dynamic time-linkage problems re-visited,” in Workshops on Applications of Evolutionary Computation.Springer, 2009, pp. 735–744.

[9] P. A. Bosman, “Learning, anticipation and time-deception inevolutionary online dynamic optimization,” in Proceedings of theannual workshop on Genetic and evolutionary computation. ACM,2005, pp. 39–47.

[10] T. T. Nguyen, Z. Yang, and S. Bonsall, “Dynamic time-linkageproblems-the challenges,” in Proceedings of the IEEE RIVF Inter-national Conference on Computing and Communication Technologies,Research, Innovation, and Vision for the Future. IEEE, 2012, pp. 1–6.

[11] Y. Jin, “Surrogate-assisted evolutionary computation: Recent ad-vances and future challenges,” Swarm and Evolutionary Computa-tion, vol. 1, no. 2, pp. 61–70, 2011.

[12] S. Liu, K. Tang, and X. Yao, “Experience-based optimization:A coevolutionary approach,” CoRR, vol. abs/1703.09865, 2017.[Online]. Available: http://arxiv.org/abs/1703.09865

[13] S. J. Louis, “Case injected genetic algorithms for learning acrossproblems,” Engineering Optimization, vol. 36, no. 2, pp. 237–247,2004.

[14] L. D. Whitley, F. Chicano, and B. W. Goldman, “Gray box opti-mization for Mk landscapes (NK landscapes and MAX-kSAT),”Evolutionary computation, vol. 24, no. 3, pp. 491–519, 2016.

[15] R. Santana, “Gray-box optimization and factorized distribu-tion algorithms: where two worlds collide,” arXiv preprintarXiv:1707.03093, 2017.

[16] M. A. Potter and K. A. De Jong, “A cooperative coevolutionaryapproach to function optimization,” in Proc. of International Con-ference on Parallel Problem Solving from Nature, vol. 2, 1994, pp.249–257.

[17] Z. Yang, K. Tang, and X. Yao, “Multilevel cooperative coevolutionfor large scale optimization,” in Proc. of IEEE Congress on Evolu-tionary Computation, June 2008, pp. 1663–1670.

[18] M. N. Omidvar, X. Li, Z. Yang, and X. Yao, “Cooperative co-evolution for large scale optimization through more frequentrandom grouping,” in Proc. of IEEE Congress on EvolutionaryComputation, 2010, pp. 1754–1761.

[19] X. Li and X. Yao, “Cooperatively coevolving particle swarmsfor large scale optimization,” IEEE Transactions on EvolutionaryComputation, vol. 16, no. 2, pp. 210–224, April 2012.

[20] M. N. Omidvar, X. Li, Y. Mei, and X. Yao, “Cooperative co-evolution with differential grouping for large scale optimization,”IEEE Transactions on Evolutionary Computation, vol. PP, no. 99, pp.1–1, 2013.

[21] M. N. Omidvar, M. Yang, Y. Mei, X. Li, and X. Yao, “DG2: A fasterand more accurate differential grouping for large-scale black-box optimization,” IEEE Transactions on Evolutionary Computation,vol. PP, no. PP, p. (accepted on 30/3/2017), 2017.

[22] Y. Mei, M. N. Omidvar, X. Li, and X. Yao, “A competitive divide-and-conquer algorithm for unconstrained large-scale black-boxoptimization,” ACM Transactions on Mathematical Software (TOMS),vol. 42, no. 2, p. 13, 2016.

[23] M. N. Omidvar, X. Li, and X. Yao, “Smart use of computationalresources based on contribution for cooperative co-evolutionaryalgorithms,” in Proc. of Genetic and Evolutionary Computation Con-ference. ACM, 2011, pp. 1115–1122.

[24] S. Mahdavi, M. E. Shiri, and S. Rahnamayan, “Metaheuristics inlarge-scale global continues optimization: A survey,” InformationSciences, vol. 295, pp. 407–428, 2015.

[25] M. N. Omidvar, X. Li, and K. Tang, “Designing benchmarkproblems for large-scale continuous optimization,” InformationSciences, vol. 316, pp. 419–436, 2015.

[26] E. Anderson, “Discontinuous plane rotations and the symmetriceigenvalue problem,” 2000.

[27] B. Kazimipour, M. N. Omidvar, X. Li, and A. K. Qin, “A sensi-tivity analysis of contribution-based cooperative co-evolutionaryalgorithms,” in IEEE Congress on Evolutionary Computation. IEEE,2015, pp. 417–424.

[28] M. Yang, M. N. Omidvar, C. Li, X. Li, Z. Cai, B. Kazimipour, andX. Yao, “Efficient resource allocation in cooperative co-evolutionfor large-scale global optimization,” IEEE Transactions on Evolu-tionary Computation, vol. 21, no. 4, pp. 493–505, 2017.

[29] S. Mahdavi, S. Rahnamayan, and M. E. Shiri, “Incremental co-operative coevolution for large-scale global optimization,” SoftComputing, pp. 1–20, 2016.

[30] ——, “Cooperative co-evolution with sensitivity analysis-basedbudget assignment strategy for large-scale global optimization,”Applied Intelligence, pp. 1–26, 2017.

[31] ——, “Multilevel framework for large-scale global optimization,”Soft Computing, vol. 21, no. 14, pp. 4111–4140, 2017.

[32] M. N. Omidvar, B. Kazimipour, X. Li, and X. Yao, “CBCC3 –a contribution-based cooperative co-evolutionary algorithm withimproved exploration/exploitation balance,” in Evolutionary Com-putation (CEC), 2016 IEEE Congress on. IEEE, 2016, pp. 3541–3548.

[33] J. E. Hopcroft and R. E. Tarjan, “Efficient algorithms for graphmanipulation,” Stanford University, Stanford, CA, USA, Tech.Rep. STAN-CS-71-207, 1971.

[34] P. N. Suganthan, N. Hansen, J. J. Liang, K. Deb, Y.-P. Chen,A. Auger, and S. Tiwari, “Problem definitions and evaluationcriteria for the cec 2005 special session on real-parameter opti-mization,” KanGAL report, vol. 2005005, p. 2005, 2005.

[35] C. Li, S. Yang, and D. A. Pelta, “Benchmark generator for the ieeewcci-2012 competition on evolutionary computation for dynamicoptimization problems,” Brunel University, UK, Tech. Rep., 2011.

[36] M. N. Omidvar, Y. Mei, and X. Li, “Effective decomposition oflarge-scale separable continuous functions for cooperative co-evolutionary algorithms,” in Proceedings of the IEEE Congress onEvolutionary Computation. IEEE, 2014, pp. 1305–1312.

[37] Z. Yang, K. Tang, and X. Yao, “Self-adaptive differential evolutionwith neighborhood search,” in Proc. of IEEE Congress on Evolution-ary Computation, 2008, pp. 1110–1116.

[38] G. N. Vanderplaats, “Very large scale optimization,” NationalAeronautics and Space Administration (NASA), Langley ResearchCenter, Colorado, US, Tech. Rep. NASA/CR-2002-211768, 2002.

solving incremental optimization problems via cooperative

Documents