Manytasking Jmetal代碼反向解析3_MMZDT
覺得有用的話,歡迎一起討論相互學習~Follow Me
- 這是我在寫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);
Summary
