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);