Manytasking Jmetal代码反向解析3_MMZDT
觉得有用的话,欢迎一起讨论相互学习~
- 这是我在写Manytask optimization时的笔记,代码地址可以下载
相关文献
[1]反向解析_1 Manytasking optimization MATP
[2]旋转矩阵
[3]Jmetal Problem和Problem Set的变量范围
[4]MATP ManyTask Multitask Problem和Solution的变量范围
[5]MATP1生成测试SolutionSet
[6]Manytasking MATP MOOMFO 中G函数
[7]Manytasking Optimization MMDTLZ
MATP2
public static ProblemSet getProblem() throws IOException {
int taskNumber=50;
ProblemSet problemSet = new ProblemSet(taskNumber);
for(int i=1;i<=taskNumber;i++)
problemSet.add(getT(i).get(0));
return problemSet;
}
public static ProblemSet getT(int taskID) throws IOException {
ProblemSet problemSet = new ProblemSet(1);
MMZDT prob = new MMZDT(50, 1, -100,100);
prob.setGType("mean");
prob.setHType("concave");
double[][] matrix = IO.readMatrixFromFile("MData/M2/M2_"+taskID+".txt");
double shiftValues[] = IO.readShiftValuesFromFile("SVData/S2/S2_"+taskID+".txt");
prob.setRotationMatrix(matrix);
prob.setShiftValues(shiftValues);
((Problem)prob).setName("MATP2-"+taskID);
problemSet.add(prob);
return problemSet;
}
- 看的出来,MATP2中也有50个任务,并且下限为-100,上限为100,G函数为mean,T函数为concave
MMZDT初始化与生成
public class MMZDT extends Problem {
Integer k_;
String gType_;
String f1Type_;
- 首先可以看出MMZDT也是集成了Problem
public MMZDT(int numberOfVariables, int k, double lg, double ug) {
numberOfObjectives_ = 2;
numberOfVariables_ = numberOfVariables;
k_ = k;
gType_ = "sphere";
f1Type_ = "linear";
hType_ = "convex";
upperLimit_ = new double[numberOfVariables_];
lowerLimit_ = new double[numberOfVariables_];
for (int var = 0; var < k_; var++) {
lowerLimit_[var] = 0.0;
upperLimit_[var] = 1.0;
} // for
for (int var = k_; var < numberOfVariables; var++) {
lowerLimit_[var] = lg;
upperLimit_[var] = ug;
}
shiftValues_ = new double[numberOfVariables_ - k_];
for (int i = 0; i < shiftValues_.length; i++)
shiftValues_[i] = 0;
rotationMatrix_ = new double[numberOfVariables_ - k_][numberOfVariables_ - k_];
for (int i = 0; i < rotationMatrix_.length; i++) {
for (int j = 0; j < rotationMatrix_.length; j++) {
if (i != j)
rotationMatrix_[i][j] = 0;
else
rotationMatrix_[i][j] = 1;
}
}
}
- 目标数量都设置为2
- 初始化默认G函数为sphere,F1函数为line,H函数convex,注意:在MMDTLZ问题中具体只使用了G函数了,完全没有F1函数,对H函数没有定义,只是为了保持一致性才加上了H函数
- 看出k应该是使用的重要的变量,此处设置k为1,和MMDTLZ一样,k之前的变量被设置为[0,1]而其后的变量都设置为[lg,up]
- 和DTLZ一样,旋转矩阵和shift和XII中的变量维度一致,k维度之前的变量不会受到偏移向量和旋转矩阵的影响。
evaluate
scaleVariables
- 将统一表示的solution从[0,1]空间恢复到原有的空间,具体可以参照
MATP ManyTask Multitask Problem和Solution的变量范围
XI和XII
- 将k维之前的设置为XI而其后的设置为XII,具体可以参照
Manytasking Optimization MMDTLZ
对XII进行偏移和旋转
- 和MMDTLZ中相同,具体可以参照Manytasking Optimization MMDTLZ
xII = transformVariables(xII);
前方高能,不一样的地方来了
evalF1(xI)
- 对于双目标中XI中只有一个元素,然而也停不住其作妖的步伐
double f1 = evalF1(xI);
evalF1
double evalF1(double[] xI) {
if (f1Type_.equalsIgnoreCase("linear"))
return F1_linear(xI);
else if (f1Type_.equalsIgnoreCase("nonlinear"))
return F1_nonlinear(xI);
else {
System.out.println("Error: f1 function type " + f1Type_ + " invalid");
return Double.NaN;
}
}
F1_linear(xI) and F1_nonlinear(xI)
double F1_linear(double xI[]) {
double sum = 0;
for (int i = 0; i < xI.length; i++)
sum += xI[i];
return sum / xI.length;
}
double F1_nonlinear(double xI[]) {
double r = 0;
for (int i = 0; i < xI.length; i++)
r += (xI[i] * xI[i]);
r = Math.sqrt(r);
return 1 - Math.exp(-4 * r) * Math.pow(Math.sin(5 * Math.PI * r), 4);
}
- 注意:
- 虽然对于双目标ZDT问题,XI是个只有一个元素的double[]数组,但是注意其返回值却是根据XI计算得到的一个double类型的返回值
evalG(XII)
double g = evalG(xII) + 1;
- 和MMDTLZ中相同,具体可以参照Manytasking MATP MOOMFO 中G函数
double evalG(double[] xII) throws JMException {
if (gType_.equalsIgnoreCase("sphere"))
return GFunctions.getSphere(xII);
else if (gType_.equalsIgnoreCase("rosenbrock"))
return GFunctions.getRosenbrock(xII);
else if (gType_.equalsIgnoreCase("ackley"))
return GFunctions.getAckley(xII);
else if (gType_.equalsIgnoreCase("griewank"))
return GFunctions.getGriewank(xII);
else if (gType_.equalsIgnoreCase("rastrigin"))
return GFunctions.getRastrigin(xII);
else if (gType_.equalsIgnoreCase("mean"))
return GFunctions.getMean(xII);
else {
System.out.println("Error: g function type " + gType_ + " invalid");
return Double.NaN;
}
}
前方高能,不一样的地方来了
f2 = g * evalH(f1, g)
- f1是根据XI计算的,g是根据XII计算的,因此f2是根据solution的所有维度进行计算的
double evalH(double f1, double g) {
if (hType_.equalsIgnoreCase("convex"))//凸的
return H_convex(f1, g);
else if (hType_.equalsIgnoreCase("concave"))//凹的
return H_nonconvex(f1, g);
else {
System.out.println("Error: f1 function type " + f1Type_ + " invalid");
return Double.NaN;
}
}
double H_convex(double f1, double g) {
return 1 - Math.pow(f1 / g, 0.5);
}
double H_nonconvex(double f1, double g) {
return 1 - Math.pow(f1 / g, 2);
}
目标函数计算结果
double f1 = evalF1(xI);
double g = evalG(xII) + 1;
double f2 = g * evalH(f1, g);
solution.setGFunValue(g);
// System.out.println("g: " + g);
solution.setObjective(startObjPos_, f1);
solution.setObjective(startObjPos_ + 1, f2);