我在一个很小的研究团队工作,在

Scala中创建/改编遗传算法库,用于使用Scientific Worklow System进行分布式计算,在我们的例子中,我们使用开源OpenMole软件(

http://www.openmole.org/).

最近,我尝试理解并重新实现在JMetal Metaheuristics库(http://jmetal.sourceforge.net/)中编写的SBX交叉运算符,以使其在我们的Scala库中的功能版本中进行调整.

第一个问题,我不了解JMetal的java版本,为什么他们使用两个不同的beta值？

> beta1在方程式中使用min [(y1-yL),…]的第一个arg

> beta2使用min […,(yu – y2)]的第二个arg)

Beta 1和2用于计算alpha值和2(所以这里和jmetal我们还有两个alpha不同的值alpha1和2)…

同样的问题/问题,我们在jmetal两个计算betaq(java代码)或Deb方程,结果：

第二个问题,在SBX的伪算法中,(2)和(3)过程中使用的符号的含义是什么,以及与简单β的差异？特别是当我们想要计算交叉父母的孩子/后代时,就像这里：

编辑

>更正no-op if / else块

> jmetal中的代码作者给了我Nsga-II算法原始源代码的链接,他解释说Deb的SBX描述与他的实现不同：/

我不明白jmetal和原始源代码中的描述和实现之间的区别,你有解释吗？

>更正if / else返回地图

开始翻译成scala

class SBXBoundedCrossover[G <: gagenome f gagenomefactory random=""> Double = _.nextDouble) extends CrossOver [G, F] {

def this(rate: Double) = this( _ => rate)

def crossOver (genomes : IndexedSeq [G], factory: F) (implicit aprng : Random) = {

val g1 = genomes.random

val g2 = genomes.random

val crossoverRate = rate(aprng)

val EPS = 1.0e-14

val numberOfVariables = g1.wrappedValues.size

val distributionIndex = 2

val variableToMutate = (0 until g1.wrappedValues.size).map{x => !(aprng.nextDouble < 0.5)}

//crossover probability

val offspring = {

if (aprng.nextDouble < crossoverRate) {

(variableToMutate zip (g1.wrappedValues zip g2.wrappedValues)) map {

case (b, (g1e, g2e)) =>

if(b) {

if (abs(g1e - g2e) > EPS){

val y1 = min(g1e, g2e)

val y2 = max(g2e, g1e)

var yL = 0.0 //g1e.getLowerBound

var yu = 1.0 //g1e.getUpperBound

var rand = aprng.nextDouble // ui

var beta1 = 1.0 + (2.0 * (y1 - yL)/(y2 - y1))

var alpha1 = 2.0 - pow(beta1,-(distributionIndex+1.0))

var betaq1 = computebetaQ(alpha1,distributionIndex,rand)

//calcul offspring 1 en utilisant betaq1, correspond au β barre

var c1 = 0.5 * ((y1 + y2) - betaq1 * (y2 - y1))

// -----------------------------------------------

var beta2 = 1.0 + (2.0 * (yu - y2) / (y2 - y1))

var alpha2 = 2.0 - pow(beta2, -(distributionIndex + 1.0))

var betaq2 = computebetaQ(alpha2,distributionIndex,rand)

//calcul offspring2 en utilisant betaq2

var c2 = 0.5 * ((y1 + y2) + betaq2 * (y2 - y1))

if (c1 < yL) c1 = yL

if (c1 > yu) c1 = yu

if (c2 < yL) c2 = yL

if (c2 > yu) c2 = yu

if (aprng.nextDouble <= 0.5) {

(c2,c1)

} else {

(c1, c2)

}

}else{

(g1e, g2e)

}

}else{

(g2e, g1e)

}

}

}else{

// not so good here ...

(g1.wrappedValues zip g2.wrappedValues)

}

}

(factory.buildGenome(offspring.map{_._1}), factory.buildGenome(offspring.map{_._2}))

}

def computebetaQ(alpha:Double, distributionIndex:Double, rand:Double):Double = {

if (rand <= (1.0/alpha)){

pow ((rand * alpha),(1.0 / (distributionIndex + 1.0)))

} else {

pow ((1.0 / (2.0 - rand * alpha)),(1.0 / (distributionIndex + 1.0)))

}

}

非常感谢您的建议或帮助解决这个问题.

SR