quadraticparameteroptimizationoperator.java

著名的开源仿真软件yale

	    // - Warnung wenn in gegebenem Parameter-Bereich
	    // - Fehler sonst
	    int threetok=1;
	    for(int i=0;i<nrParameters;i++){ threetok *= 3; };

	    LogService.logMessage("Optimising "+nrParameters+" parameters", LogService.MINIMUM);


	    Matrix Designmatrix = new Matrix(threetok,nrParameters+nrParameters*(nrParameters+1)/2+1);
	    Matrix y = new Matrix(threetok,1);

	    paramIndex = 0;
	    for(int i=parameterList.size()-1;i>=0;i--){
		if((values[i]).length > 2){
		    currentIndex[i] = bestIndex[i]-1;
		}
		else{
		    currentIndex[i] = bestIndex[i];
		};
		paramIndex = paramIndex*(values[i]).length+currentIndex[i];
	    };

	    int row=0;
	    int c;
	    while(row < Designmatrix.getRowDimension()){
		y.set(row,0,allParameters[paramIndex].getPerformance().getMainCriterion().getValue()); // Performance Zahl?		
		Designmatrix.set(row,0,1.0);
		c = 1;
		// compute A
		for(int i=0;i<nrParameters;i++){
		    if((values[i]).length > 2){
			Designmatrix.set(row,c,param2coded(values[i][currentIndex[i]], logBase[i]));
			c++;
		    };
		};
		// compute C
		for(int i=0;i<nrParameters;i++){
		    if((values[i]).length > 2){
			for(int j=i+1;j<nrParameters;j++){
			    if((values[j]).length > 2){
				Designmatrix.set(row,c,
						 param2coded(values[i][currentIndex[i]], logBase[i])*
						 param2coded(values[j][currentIndex[j]], logBase[j]));
				c++;
			    };
			};
		    };
		};
		// compute Q:
		for(int i=0;i<nrParameters;i++){
		    if((values[i]).length > 2){
			Designmatrix.set(row,c,
					 param2coded(values[i][currentIndex[i]], logBase[i])*
					 param2coded(values[i][currentIndex[i]], logBase[i]));
			c++;
		    };
		};

		// update currentIndex and paramIndex
		int k=0;
		c=1;
		while(k<parameterList.size()){
		    if((values[k]).length > 2){
			currentIndex[k]++;
			paramIndex+=c;
			if(currentIndex[k] > bestIndex[k]+1){
			    currentIndex[k] = bestIndex[k]-1;
			    paramIndex -= 3*c;
			    c *= values[k].length;
			    k++;
			}
			else{
			    break;
			};
		    }
		    else{
			c *= values[k].length;
			k++;
		    };
		};

		row++;
	    };

	    Matrix x = Designmatrix.solve(y);
	    String[] Qvalues = new String[parameterList.size()];
	    int pc = 0;
	    boolean ok=true;
	    for (int j = 0; j < parameterList.size(); j++) {
		if((values[j]).length > 2){
		    if((x.get(pc,0) > Double.parseDouble(values[j][bestIndex[j]+1])) ||
		       (x.get(pc,0) < Double.parseDouble(values[j][bestIndex[j]-1]))){
			LogService.logMessage("Parameter "+parameters[j]+" exceeds region of interest ("+x.get(pc,0)+")", LogService.WARNING);
			if(ifExceedsRegion == CLIP){
			    // clip to bound
			    if(x.get(pc,0) > Double.parseDouble(values[j][bestIndex[j]+1])){
				x.set(pc,0,Double.parseDouble(values[j][bestIndex[j]+1]));
			    }
			    else{
				x.set(pc,0,Double.parseDouble(values[j][bestIndex[j]-1]));
			    };
			}
			else if(ifExceedsRegion == FAIL){
			    ok = false;
			};
		    };
		    if((x.get(pc,0) < Double.parseDouble(values[j][0])) ||
		       (x.get(pc,0) > Double.parseDouble(values[j][values[j].length-1]))){
			LogService.logMessage("Parameter "+parameters[j]+" exceeds range ("+x.get(pc,0)+")", LogService.WARNING);
			if(ifExceedsRange == IGNORE){
			    // ignore error
			    LogService.logMessage("  but no measures taken. Check parameters manually!", LogService.WARNING);
			}
			else if(ifExceedsRange == CLIP){
			    //  clip to bound
			    if(x.get(pc,0) > Double.parseDouble(values[j][0])){
				x.set(pc,0,Double.parseDouble(values[j][0]));
			    }
			    else{
				x.set(pc,0,Double.parseDouble(values[j][values[j].length-1]));
			    };
			}
			else{
			    ok = false;
			};
		    };


		    Qvalues[j] = coded2param(x.get(pc,0), logBase[j]);
		    pc++;
		    // Werte im richtigen Bereich?
		}
		else{
		    Qvalues[j] = values[j][bestIndex[j]];
		};
	    };
	   
	    LogService.logMessage("Optimised parameter set:", LogService.TASK);
	    for (int j = 0; j < operators.length; j++) {
		operators[j].getParameters().setParameter(parameters[j], Qvalues[j]);
		LogService.logMessage("  "+operators[j]+"."+parameters[j]+
				      " = " + Qvalues[j], LogService.TASK);
	    }
	    
	    if(ok){
		setInput(input.copy());
		PerformanceVector Qperformance = getPerformance();
		LogService.logMessage("Old: "+(best.getPerformance().getMainCriterion().getValue()), LogService.STATUS);
		LogService.logMessage("New: "+(Qperformance.getMainCriterion().getValue()), LogService.STATUS);
		if (Qperformance.compareTo(best.getPerformance()) > 0) {
		    best = new ParameterSet(operators, parameters, Qvalues, Qperformance);
		    // log
		    LogService.logMessage("Optimised parameter set does increase the performance",LogService.STATUS);
		}
		else{
		    // anderes log
		    LogService.logMessage("Could not increase performance by quadratic optimization",LogService.STATUS);
		};
	    }
	    else{
		// not ok
		LogService.logMessage("Parameters outside admissible range, not using optimised parameter set.", LogService.WARNING);
	    };
	}
	else{
	    // Warning: no parameters to optimize
	    LogService.logMessage("No parameters to optimize",LogService.WARNING);
	};

	// end quadratic optimization

	String parameterFile = getParameterAsString("parameter_file");
	if (parameterFile != null) {
	    try {
		LogService.logMessage("Writing parameter file: '"+parameterFile+"'", LogService.TASK);
		best.write(new PrintWriter(new FileWriter(getExperiment().resolveFileName(parameterFile))));
	    } catch (IOException e) {
		LogService.logMessage("Cannot write parameter file: '"+parameterFile+"'", LogService.ERROR);
	    }
	}

	return new IOObject[] { best, best.getPerformance() };
    }


    public List getParameterTypes() {
	List types = super.getParameterTypes();
	types.add(new ParameterTypeList("parameters", "A list of parameters to optimise", 
					new ParameterTypeString("value", "The values of the parameter (comma-separated")));
	types.add(new ParameterTypeFile("parameter_file", "A file that the optimal parameter set will be written to.", true));

	types.add(new ParameterTypeCategory("if_exceeds_region", "What to do if range is exceeded.", EXCEED_BEHAVIORS, CLIP));	
	types.add(new ParameterTypeCategory("if_exceeds_range", "What to do if range is exceeded.", EXCEED_BEHAVIORS, FAIL));

	return types;
    }


    /** Applies the inner operator and employs the PerformanceEvaluator for calculating a list
     *  of performance criteria which is returned. */
    protected PerformanceVector getPerformance() throws OperatorException {
	IOObject[] evalout = super.apply();
	IOContainer evalCont = new IOContainer(evalout);
	return (PerformanceVector)evalCont.getInput(PerformanceVector.class);
    }

    public Class[] getInputClasses() {
	return new Class[0];
    }

    public Class[] getOutputClasses() {
	return OUTPUT_CLASSES;
    }

    public Class[] checkIO(Class[] input) throws IllegalInputException {
	for (int i = 0; i < getNumberOfOperators(); i++) {
	    Operator o = getOperator(i);
	    input = o.checkIO(input);
	}
	return OUTPUT_CLASSES;
    }


    /** Returns the highest possible value for the maximum number of innner operators. */
    public int getMaxNumberOfInnerOperators() { return Integer.MAX_VALUE; }
    /** Returns 1 for the minimum number of innner operators. */
    public int getMinNumberOfInnerOperators() { return 1; }

    public int getNumberOfSteps() {
	return 1+numberOfCombinations * (getNumberOfChildrensSteps() + 1);
    }

}