org.eclipse.stem.analysis.automaticexperiment/src/org/eclipse/stem/analysis/automaticexperiment/SimplexAlgorithmExecuter.java - stem/org.eclipse.stem - Git at Google

 package org.eclipse.stem.analysis.automaticexperiment;

 /*******************************************************************************
  * Copyright (c) 2009 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/

 /**
  * Implementation was taken from: http://www.ee.ucl.ac.uk/~mflanaga/java/Minimisation.html#simplex
  */

 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.List;

 import org.eclipse.core.runtime.Platform;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.stem.analysis.ErrorFunction;
 import org.eclipse.stem.analysis.ErrorResult;
 import org.eclipse.stem.analysis.ScenarioInitializationException;
 import org.eclipse.stem.analysis.impl.ReferenceScenarioDataMapImpl;
 import org.eclipse.stem.analysis.util.CSVscenarioLoader;
 import org.eclipse.stem.core.model.Decorator;
 import org.eclipse.stem.core.model.IntegrationDecorator;
 import org.eclipse.stem.core.scenario.Scenario;
 import org.eclipse.stem.diseasemodels.standard.AggregatingSIDiseaseModel;
 import org.eclipse.stem.diseasemodels.standard.DiseaseModel;
 import org.eclipse.stem.jobs.simulation.ISimulation;
 import org.eclipse.stem.jobs.simulation.Simulation;
 import org.eclipse.stem.util.loggers.views.CustomCSVLogger;

 import automaticexperiment.AutomaticExperiment;
 import automaticexperiment.ModifiableParameter;

 public class SimplexAlgorithmExecuter
 	extends AbstractErrorAnalysisAlgorithm {

 	private ISimulation simulation = null;
 	private CustomCSVLogger csvLogger = null;
 	private final static String SIMULATION_OUTPUT_DIR = Platform.getLocation() + File.separator + "AutoExpTempDir";
 	private final static String LOG_FILE_NAME = SIMULATION_OUTPUT_DIR+File.separator+"resultLog.csv";
 	static String LS = System.getProperty("line.separator");
 	private final CustomSimulationManager simMgr = CustomSimulationManager.getManager();
 	private ReferenceScenarioDataMapImpl ref;

 	/**
 	 * @see org.eclipse.stem.analysis.automaticexperiment.AbstractErrorAnalysisAlgorithm#execute()
 	 */
 	@Override
 	public void execute() {
 		double prevmin = Double.MAX_VALUE;
 		double [] prevvals = new double[initialParamsValues.length];
 		for(;;) {
 			for(int i=0;i<initialParamsValues.length;++i) prevvals[i] = initialParamsValues[i];
 			long before = System.currentTimeMillis();
 			simplexAlgorithm.execute(simplexFnToMinimize,  initialParamsValues, paramsInitialSteps, tolerance, this.maxNumOfIterations);
 			long after = System.currentTimeMillis();

 			if(!this.repeat) {
 				System.out.println("\n\nTime to execute the Nedler-Mead Algorithm: " + (after-before)/1000 + " seconds");
 				System.out.println("Minimum value: " + simplexAlgorithm.getMinimumFunctionValue());
 				System.out.println("Parameters values: " + Arrays.toString(simplexAlgorithm.getMinimumParametersValues()));
 				break;
 			}
 			double newmin = simplexAlgorithm.getMinimumFunctionValue();
 			if(newmin >= prevmin) {
 				System.out.println("\n\nTime to execute the Nedler-Mead Algorithm: " + (after-before)/1000 + " seconds");
 				System.out.println("Minimum value: " + prevmin);
 				System.out.println("Parameters values: " + Arrays.toString(prevvals));
 				break; // we couldn't improve
 			}
 			// Not same, reinit with new minimum
 			prevmin = simplexAlgorithm.getMinimumFunctionValue();
 			for(int i=0;i<initialParamsValues.length;++i){
 				initialParamsValues[i] = simplexAlgorithm.getMinimumParametersValues()[i];
 				prevvals[i] =  simplexAlgorithm.getMinimumParametersValues()[i];
 			}
 		}
 	}

 	@Override
 	public void init(AutomaticExperiment automaticExperiment) {
 		super.init(automaticExperiment);
 		simplexFnToMinimize = new NedlearMeadSimplexFunction(parameters, baseScenario, errorFunction);
 		try {
 			CSVscenarioLoader loader1 = new CSVscenarioLoader(referenceDataDirectory);
 			ref = loader1.parseAllFiles(2);
 		} catch (ScenarioInitializationException e) {
 			e.printStackTrace();
 		}
 	}

 	@Override
 	public void setParameters(List<ModifiableParameter> parameters) {
 		super.setParameters(parameters);

 		//Set lower and upper bounds constraints for the parameters
 		int paramIndex=0;
 		for (final ModifiableParameter param:parameters) {
 			simplexAlgorithm.setParameterLimits(paramIndex, param.getLowerBound(), param.getUpperBound());
 			paramIndex++;
 		}
 	}

 	/**
 	 *
 	 */
 	public class NedlearMeadSimplexFunction
 		implements SimplexFunction
 	{
 	    private ErrorFunction errorFunction = null;
 	    private String[] parameterNames = null;
 	    private FileWriter resultWriter;
 	    private URI[] decoratorURIs = null;
 		public NedlearMeadSimplexFunction(
 				final List<ModifiableParameter> parameters,
 				final Scenario pBaseScenario,
 				final ErrorFunction errorFunction) {

 			try {
 				resultWriter = new FileWriter(LOG_FILE_NAME);
 				baseScenario = pBaseScenario;
 				this.errorFunction = errorFunction;
 				if (parameters != null) {
 					parameterNames = new String[parameters.size()];
 					decoratorURIs = new URI[parameters.size()];
 					int i=0;
 					for (final ModifiableParameter param:parameters) {
 						decoratorURIs[i]=param.getTargetURI();
 						parameterNames[i++] = param.getFeatureName();
 						resultWriter.write(parameterNames[i-1]);
 						resultWriter.write(",");
 					}
 					resultWriter.write("error");
 					resultWriter.write(LS);
 				}
 			} catch(IOException ioe) {
 				ioe.printStackTrace();
 			}
 		}

 		public double getValue(double[] parameters) {


 			simulation = createSimulation(baseScenario);
 			simulation.setSequenceNumber(simulation.getSequenceNumber()+1);

 			// Descend into the Scenario looking for something with a double field
 			final EList<Decorator> decs = baseScenario.getCanonicalGraph().getDecorators();

 			Decorator defaultDecorator = null;
 			for (Decorator decorator : decs) {
 				if (decorator instanceof DiseaseModel) {
 					defaultDecorator = decorator;
 					break;
 				}
 			}

 			for(int i=0;i<parameterNames.length;++i) {
 				Decorator decorator = defaultDecorator;
 				if(decoratorURIs[i] != null)
 					for(Decorator scenarioDec:decs)
 						if(decoratorURIs[i].toString().equals(scenarioDec.getURI().toString())) {
 							decorator = scenarioDec;
 							break;
 						}
 				for (EAttribute attribute : decorator.eClass().getEAllAttributes())
 					if(attribute.getName().equals(parameterNames[i]))
 						decorator.eSet(attribute, new Double(parameters[i]));
 			}

 			csvLogger = new CustomCSVLogger(SIMULATION_OUTPUT_DIR, simulation, (IntegrationDecorator) defaultDecorator);

 			// This will reinit the infectors/inoc etc to the new values
 			baseScenario.reset();


 			//Run the simulation with the new parameters and return the error value
 			System.out.println("Running the simulation with the following parameters: ");
 			System.out.println("\tParameters Names: " + Arrays.toString(parameterNames));
 			System.out.println("\tParameters Values: " + Arrays.toString(parameters));
 			double error = 0.0;
 			try {
 				for(double val:parameters) resultWriter.write(val+",");
 				runSimulation(simulation);

 				error = getErrorValue(simulation.getUniqueIDString());
 				System.out.println(" Error is: " + error);
 				resultWriter.write(error+"");
 				resultWriter.write(LS);
 				resultWriter.flush();
 			} catch(IOException ioe) {
 				ioe.printStackTrace();
 			}
 			cleanup();

 			return error;
 		}

 		private double getErrorValue(String simulationUniqueId) {
 			ErrorResult result = null;
 			try {
 				final EList<Decorator> decs = baseScenario.getCanonicalGraph().getDecorators();

 				DiseaseModel defaultDecorator = null;
 				for (Decorator decorator : decs) {
 					if (decorator instanceof DiseaseModel) {
 						defaultDecorator = (DiseaseModel)decorator;
 						break;
 					}
 				}

 				CSVscenarioLoader loader2 = new CSVscenarioLoader(SIMULATION_OUTPUT_DIR + File.separator + simulationUniqueId +"/"+defaultDecorator.getDiseaseName());
 				ReferenceScenarioDataMapImpl data = loader2.parseAllFiles(2);

 				result = errorFunction.calculateError(ref, data);
 			} catch (ScenarioInitializationException e) {
 				e.printStackTrace();
 			}
 			return result.getError();
 		}

 		private void runSimulation(final ISimulation simulationToRun) {
 			long before = System.currentTimeMillis();
 			simulationToRun.run();
 			try {
 				simulationToRun.join();
 			} catch (InterruptedException e) {
 				e.printStackTrace();
 			}
 			simulationToRun.stop();

 			long after = System.currentTimeMillis();
 			System.out.println("It took " + (after-before)/1000 + " seconds to run the simulation");
 		}

 		private void cleanup() {
 			if (csvLogger != null) {
 				csvLogger.close();
 				csvLogger = null;
 			}
 			simMgr.removeActiveSimulation(simulation);
 			((Simulation)simulation).destroy();
 			simulation = null;
 			CustomSimulationManager.resetSimulationManager();
 		}

 		private ISimulation createSimulation(Scenario scenario) {
 			Simulation simulation = (Simulation)simMgr.createSimulation(scenario, null);
 			simulation.simulationSleep = false;
 			return simulation;
 		}
 	}
 }
	package org.eclipse.stem.analysis.automaticexperiment;

	/*******************************************************************************
	* Copyright (c) 2009 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/

	/**
	* Implementation was taken from: http://www.ee.ucl.ac.uk/~mflanaga/java/Minimisation.html#simplex
	*/

	import java.io.File;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.util.Arrays;
	import java.util.List;

	import org.eclipse.core.runtime.Platform;
	import org.eclipse.emf.common.util.EList;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EAttribute;
	import org.eclipse.stem.analysis.ErrorFunction;
	import org.eclipse.stem.analysis.ErrorResult;
	import org.eclipse.stem.analysis.ScenarioInitializationException;
	import org.eclipse.stem.analysis.impl.ReferenceScenarioDataMapImpl;
	import org.eclipse.stem.analysis.util.CSVscenarioLoader;
	import org.eclipse.stem.core.model.Decorator;
	import org.eclipse.stem.core.model.IntegrationDecorator;
	import org.eclipse.stem.core.scenario.Scenario;
	import org.eclipse.stem.diseasemodels.standard.AggregatingSIDiseaseModel;
	import org.eclipse.stem.diseasemodels.standard.DiseaseModel;
	import org.eclipse.stem.jobs.simulation.ISimulation;
	import org.eclipse.stem.jobs.simulation.Simulation;
	import org.eclipse.stem.util.loggers.views.CustomCSVLogger;

	import automaticexperiment.AutomaticExperiment;
	import automaticexperiment.ModifiableParameter;

	public class SimplexAlgorithmExecuter
	extends AbstractErrorAnalysisAlgorithm {

	private ISimulation simulation = null;
	private CustomCSVLogger csvLogger = null;
	private final static String SIMULATION_OUTPUT_DIR = Platform.getLocation() + File.separator + "AutoExpTempDir";
	private final static String LOG_FILE_NAME = SIMULATION_OUTPUT_DIR+File.separator+"resultLog.csv";
	static String LS = System.getProperty("line.separator");
	private final CustomSimulationManager simMgr = CustomSimulationManager.getManager();
	private ReferenceScenarioDataMapImpl ref;

	/**
	* @see org.eclipse.stem.analysis.automaticexperiment.AbstractErrorAnalysisAlgorithm#execute()
	*/
	@Override
	public void execute() {
	double prevmin = Double.MAX_VALUE;
	double [] prevvals = new double[initialParamsValues.length];
	for(;;) {
	for(int i=0;i<initialParamsValues.length;++i) prevvals[i] = initialParamsValues[i];
	long before = System.currentTimeMillis();
	simplexAlgorithm.execute(simplexFnToMinimize, initialParamsValues, paramsInitialSteps, tolerance, this.maxNumOfIterations);
	long after = System.currentTimeMillis();

	if(!this.repeat) {
	System.out.println("\n\nTime to execute the Nedler-Mead Algorithm: " + (after-before)/1000 + " seconds");
	System.out.println("Minimum value: " + simplexAlgorithm.getMinimumFunctionValue());
	System.out.println("Parameters values: " + Arrays.toString(simplexAlgorithm.getMinimumParametersValues()));
	break;
	}
	double newmin = simplexAlgorithm.getMinimumFunctionValue();
	if(newmin >= prevmin) {
	System.out.println("\n\nTime to execute the Nedler-Mead Algorithm: " + (after-before)/1000 + " seconds");
	System.out.println("Minimum value: " + prevmin);
	System.out.println("Parameters values: " + Arrays.toString(prevvals));
	break; // we couldn't improve
	}
	// Not same, reinit with new minimum
	prevmin = simplexAlgorithm.getMinimumFunctionValue();
	for(int i=0;i<initialParamsValues.length;++i){
	initialParamsValues[i] = simplexAlgorithm.getMinimumParametersValues()[i];
	prevvals[i] = simplexAlgorithm.getMinimumParametersValues()[i];
	}
	}
	}

	@Override
	public void init(AutomaticExperiment automaticExperiment) {
	super.init(automaticExperiment);
	simplexFnToMinimize = new NedlearMeadSimplexFunction(parameters, baseScenario, errorFunction);
	try {
	CSVscenarioLoader loader1 = new CSVscenarioLoader(referenceDataDirectory);
	ref = loader1.parseAllFiles(2);
	} catch (ScenarioInitializationException e) {
	e.printStackTrace();
	}
	}

	@Override
	public void setParameters(List<ModifiableParameter> parameters) {
	super.setParameters(parameters);

	//Set lower and upper bounds constraints for the parameters
	int paramIndex=0;
	for (final ModifiableParameter param:parameters) {
	simplexAlgorithm.setParameterLimits(paramIndex, param.getLowerBound(), param.getUpperBound());
	paramIndex++;
	}
	}

	/**
	*
	*/
	public class NedlearMeadSimplexFunction
	implements SimplexFunction
	{
	private ErrorFunction errorFunction = null;
	private String[] parameterNames = null;
	private FileWriter resultWriter;
	private URI[] decoratorURIs = null;
	public NedlearMeadSimplexFunction(
	final List<ModifiableParameter> parameters,
	final Scenario pBaseScenario,
	final ErrorFunction errorFunction) {

	try {
	resultWriter = new FileWriter(LOG_FILE_NAME);
	baseScenario = pBaseScenario;
	this.errorFunction = errorFunction;
	if (parameters != null) {
	parameterNames = new String[parameters.size()];
	decoratorURIs = new URI[parameters.size()];
	int i=0;
	for (final ModifiableParameter param:parameters) {
	decoratorURIs[i]=param.getTargetURI();
	parameterNames[i++] = param.getFeatureName();
	resultWriter.write(parameterNames[i-1]);
	resultWriter.write(",");
	}
	resultWriter.write("error");
	resultWriter.write(LS);
	}
	} catch(IOException ioe) {
	ioe.printStackTrace();
	}
	}

	public double getValue(double[] parameters) {


	simulation = createSimulation(baseScenario);
	simulation.setSequenceNumber(simulation.getSequenceNumber()+1);

	// Descend into the Scenario looking for something with a double field
	final EList<Decorator> decs = baseScenario.getCanonicalGraph().getDecorators();

	Decorator defaultDecorator = null;
	for (Decorator decorator : decs) {
	if (decorator instanceof DiseaseModel) {
	defaultDecorator = decorator;
	break;
	}
	}

	for(int i=0;i<parameterNames.length;++i) {
	Decorator decorator = defaultDecorator;
	if(decoratorURIs[i] != null)
	for(Decorator scenarioDec:decs)
	if(decoratorURIs[i].toString().equals(scenarioDec.getURI().toString())) {
	decorator = scenarioDec;
	break;
	}
	for (EAttribute attribute : decorator.eClass().getEAllAttributes())
	if(attribute.getName().equals(parameterNames[i]))
	decorator.eSet(attribute, new Double(parameters[i]));
	}

	csvLogger = new CustomCSVLogger(SIMULATION_OUTPUT_DIR, simulation, (IntegrationDecorator) defaultDecorator);

	// This will reinit the infectors/inoc etc to the new values
	baseScenario.reset();


	//Run the simulation with the new parameters and return the error value
	System.out.println("Running the simulation with the following parameters: ");
	System.out.println("\tParameters Names: " + Arrays.toString(parameterNames));
	System.out.println("\tParameters Values: " + Arrays.toString(parameters));
	double error = 0.0;
	try {
	for(double val:parameters) resultWriter.write(val+",");
	runSimulation(simulation);

	error = getErrorValue(simulation.getUniqueIDString());
	System.out.println(" Error is: " + error);
	resultWriter.write(error+"");
	resultWriter.write(LS);
	resultWriter.flush();
	} catch(IOException ioe) {
	ioe.printStackTrace();
	}
	cleanup();

	return error;
	}

	private double getErrorValue(String simulationUniqueId) {
	ErrorResult result = null;
	try {
	final EList<Decorator> decs = baseScenario.getCanonicalGraph().getDecorators();

	DiseaseModel defaultDecorator = null;
	for (Decorator decorator : decs) {
	if (decorator instanceof DiseaseModel) {
	defaultDecorator = (DiseaseModel)decorator;
	break;
	}
	}

	CSVscenarioLoader loader2 = new CSVscenarioLoader(SIMULATION_OUTPUT_DIR + File.separator + simulationUniqueId +"/"+defaultDecorator.getDiseaseName());
	ReferenceScenarioDataMapImpl data = loader2.parseAllFiles(2);

	result = errorFunction.calculateError(ref, data);
	} catch (ScenarioInitializationException e) {
	e.printStackTrace();
	}
	return result.getError();
	}

	private void runSimulation(final ISimulation simulationToRun) {
	long before = System.currentTimeMillis();
	simulationToRun.run();
	try {
	simulationToRun.join();
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	simulationToRun.stop();

	long after = System.currentTimeMillis();
	System.out.println("It took " + (after-before)/1000 + " seconds to run the simulation");
	}

	private void cleanup() {
	if (csvLogger != null) {
	csvLogger.close();
	csvLogger = null;
	}
	simMgr.removeActiveSimulation(simulation);
	((Simulation)simulation).destroy();
	simulation = null;
	CustomSimulationManager.resetSimulationManager();
	}

	private ISimulation createSimulation(Scenario scenario) {
	Simulation simulation = (Simulation)simMgr.createSimulation(scenario, null);
	simulation.simulationSleep = false;
	return simulation;
	}
	}
	}