/***
    * 
    */
   package yawn.optim.genetic;
   
   import java.lang.reflect.InvocationTargetException;
   import java.util.Arrays;
   import java.util.Comparator;
   import java.util.List;
  
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.collections.KeyValue;
  import org.apache.commons.collections.keyvalue.DefaultKeyValue;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.jgap.Chromosome;
  import org.jgap.Configuration;
  import org.jgap.DeltaFitnessEvaluator;
  import org.jgap.Genotype;
  import org.jgap.InvalidConfigurationException;
  import org.jgap.Population;
  import org.jgap.impl.DefaultConfiguration;
  import org.jgap.impl.WeightedRouletteSelector;
  
  import yawn.YawnRuntimeException;
  import yawn.config.ConfigurationException;
  import yawn.config.NeuralNetworkConfig;
  import yawn.nn.NeuralNetwork;
  import yawn.nn.committee.NetworkCommittee;
  import yawn.nn.committee.functions.Popularity;
  import yawn.optim.OptimizableModel;
  import yawn.optim.ParamerFitter;
  import yawn.util.InputOutputPattern;
  import yawn.util.Pattern;
  
  /***
   * This is yawn.optim.GeneticParameterFitter, part of the yawn project.
   * 
   * <p>$Id: GeneticParameterFitter.java,v 1.6 2005/05/09 11:04:56 supermarti Exp $</p>
   * 
   * @author Luis Mart&iacute; (luis dot marti at uc3m dot es)
   * @version $Revision: 1.6 $
   */
  public class GeneticParameterFitter extends ParamerFitter {
  
  	private static final Log log = LogFactory
  			.getLog(GeneticParameterFitter.class);
  
  	/***
  	 * 
  	 */
  	private static final long serialVersionUID = 3833462907550709300L;
  
  	/***
  	 * 
  	 * @uml.property name="fittedModel"
  	 * @uml.associationEnd multiplicity="(0 1)"
  	 */
  	protected NeuralNetwork fittedModel;
  
  	/***
  	 * 
  	 * @uml.property name="modeltoBeFittedConfig"
  	 * @uml.associationEnd multiplicity="(0 1)"
  	 */
  	protected NeuralNetworkConfig modeltoBeFittedConfig;
  
  	/***
  	 * 
  	 * @uml.property name="maxGenerations" 
  	 */
  	protected int maxGenerations;
  
  	/***
  	 * 
  	 * @uml.property name="populationSize" 
  	 */
  	protected int populationSize;
  
  	/***
  	 * 
  	 * @uml.property name="preserveFittestIndividual" 
  	 */
  	protected boolean preserveFittestIndividual;
  
  
  	/***
  	 * 
  	 */
  	public GeneticParameterFitter() {
  		super();
  	}
  
  	/***
  	 * @return Returns the fittedModel.
  	 * 
  	 * @uml.property name="fittedModel"
  	 */
  	public NeuralNetwork getFittedModel() {
 		return fittedModel;
 	}
 
 	/***
 	 * @return Returns the modeltoBeFittedConfig.
 	 * 
 	 * @uml.property name="modeltoBeFittedConfig"
 	 */
 	public NeuralNetworkConfig getModeltoBeFittedConfig() {
 		return modeltoBeFittedConfig;
 	}
 
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#getInputSize()
 	 */
 	public int getInputSize() {
 		return modeltoBeFittedConfig.getEnvironment().inputSize();
 	}
 
 	/***
 	 * @return Returns the maxGenerations.
 	 * 
 	 * @uml.property name="maxGenerations"
 	 */
 	public int getMaxGenerations() {
 		return maxGenerations;
 	}
 
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#getNeuralNetworkName()
 	 */
 	public String getNeuralNetworkName() {
 		// TODO Auto-generated method stub
 		return "Genetic Algorithm Fitter of Model Parameters";
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#getOutputSize()
 	 */
 	public int getOutputSize() {
 		return modeltoBeFittedConfig.getEnvironment().outputSize();
 	}
 
 	/***
 	 * @return Returns the populationSize.
 	 * 
 	 * @uml.property name="populationSize"
 	 */
 	public int getPopulationSize() {
 		return populationSize;
 	}
 
 	/***
 	 * @return Returns the preserveFittestIndividual.
 	 * 
 	 * @uml.property name="preserveFittestIndividual"
 	 */
 	public boolean isPreserveFittestIndividual() {
 		return preserveFittestIndividual;
 	}
 
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#oneLearningStep(yawn.util.Pattern,
 	 *      yawn.util.Pattern)
 	 */
 	public void oneLearningStep(Pattern input, Pattern output) {
 		// TODO Auto-generated method stub
 
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#predict(yawn.util.Pattern)
 	 */
 	public Pattern predict(Pattern input) {
 		return fittedModel.predict(input);
 	}
 
 	/***
 	 * @param fittedModel
 	 *            The fittedModel to set.
 	 * 
 	 * @uml.property name="fittedModel"
 	 */
 	public void setFittedModel(NeuralNetwork fittedModel) {
 		this.fittedModel = fittedModel;
 	}
 
 	/***
 	 * @param initialModelConfig
 	 *            The initialModelConfig to set.
 	 * 
 	 * @uml.property name="modeltoBeFittedConfig"
 	 */
 	public void setModeltoBeFittedConfig(NeuralNetworkConfig initialModelConfig) {
 		this.modeltoBeFittedConfig = initialModelConfig;
 	}
 
 	/***
 	 * @param maxGenerations
 	 *            The maxGenerations to set.
 	 * 
 	 * @uml.property name="maxGenerations"
 	 */
 	public void setMaxGenerations(int maxGenerations) {
 		this.maxGenerations = maxGenerations;
 	}
 
 	/***
 	 * @param populationSize
 	 *            The populationSize to set.
 	 * 
 	 * @uml.property name="populationSize"
 	 */
 	public void setPopulationSize(int populationSize) {
 		this.populationSize = populationSize;
 	}
 
 	/***
 	 * @param preserveFittestIndividual
 	 *            The preserveFittestIndividual to set.
 	 * 
 	 * @uml.property name="preserveFittestIndividual"
 	 */
 	public void setPreserveFittestIndividual(boolean preserveFittestIndividual) {
 		this.preserveFittestIndividual = preserveFittestIndividual;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#setup(yawn.config.NeuralNetworkConfig)
 	 */
 	public void setup(NeuralNetworkConfig config) throws ConfigurationException {
 		try {
 			BeanUtils.copyProperties(this, config);
 		} catch (IllegalAccessException e) {
 			throw new ConfigurationException(e);
 		} catch (InvocationTargetException e) {
 			throw new ConfigurationException(e);
 		}
 
 		NeuralNetwork dummyNet = modeltoBeFittedConfig
 				.configuredNetworkFactory();
 
 		if (!(dummyNet instanceof OptimizableModel)) {
 			throw new ConfigurationException(
 					"The model to be optimized does not implements yawn.optim.OptimizableModel.");
 		}
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#train(yawn.util.InputOutputPattern[])
 	 */
 	public void train(InputOutputPattern[] iop) {
 
 		Configuration conf = new DefaultConfiguration();
 
 		NeuralNetwork dummyNet = modeltoBeFittedConfig
 				.configuredNetworkFactory();
 
 		if (!(dummyNet instanceof OptimizableModel)) {
 
 			throw new YawnRuntimeException(
 					"The model to be optimazed does not implements yawn.optim.OptimizableModel.");
 		}
 
 		JGapAdapter adapter = (JGapAdapter) ((OptimizableModel) dummyNet)
 				.getAdapterInstance();
 
 		int trainSetSize = (int) Math.round(0.8 * iop.length);
 
 		InputOutputPattern[] trainSet = new InputOutputPattern[trainSetSize];
 		InputOutputPattern[] testSet = new InputOutputPattern[iop.length
 				- trainSetSize];
 		InputOutputPattern[] aset = InputOutputPattern.randomOrderList(iop);
 
 		System.arraycopy(aset, 0, trainSet, 0, trainSetSize);
 		System.arraycopy(aset, trainSetSize, testSet, 0, testSet.length);
 
 		adapter.setTrainingSet(trainSet);
 		adapter.setEvalSet(testSet);
 
 		Genotype genotype = null;
 
 		try {
 			conf.setFitnessFunction(adapter);
 			conf.setSampleChromosome(adapter.getSampleChromosome());
 			conf.setPopulationSize(populationSize);
 			conf.setPreservFittestIndividual(preserveFittestIndividual);
 			conf.setFitnessEvaluator(new DeltaFitnessEvaluator());
 
 			conf.addNaturalSelector(new WeightedRouletteSelector(), true);
 			genotype = Genotype.randomInitialGenotype(conf);
 		} catch (InvalidConfigurationException e) {
 			log.debug(e);
 			throw new YawnRuntimeException(e);
 		}
 
 		for (int i = 0; i < maxGenerations; i++) {
 			log.debug("Starting evolving generation " + i + " of "
 					+ maxGenerations + "...");
 			genotype.evolve();
 		}
 
 		log.debug("Training fittest models ...");
 
 		NetworkCommittee fit = new NetworkCommittee(new Popularity());
 		NeuralNetwork[] nets = getTopOfPopulation(adapter, genotype
 				.getPopulation(), (int)Math.round( populationSize * 0.2) + 1);
 
 		for (int i = 0; i < nets.length; i++) {
 			fit.addCommitteeMembers(nets[i]);
 		}
 
 		fittedModel = fit;
 		fittedModel.train(iop);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see yawn.nn.NeuralNetwork#yieldConfiguration()
 	 */
 	public NeuralNetworkConfig yieldConfiguration() {
 		NeuralNetworkConfig res = new GeneticParameterFitterConfig();
 		try {
 			BeanUtils.copyProperties(res, this);
 		} catch (IllegalAccessException e) {
 			throw new YawnRuntimeException(e);
 		} catch (InvocationTargetException e) {
 			throw new YawnRuntimeException(e);
 		}
 		return res;
 	}
 
 	private NeuralNetwork[] getTopOfPopulation(JGapAdapter adapter,
 			Population population, int amount) {
 		List chromosomes = population.getChromosomes();
 
 		// HashMap map = new HashMap();
 		//
 		// for (Iterator i = chromosomes.iterator(); i.hasNext();) {
 		// Chromosome chromo = (Chromosome) i.next();
 		// double fitness = adapter.evaluate(chromo);
 		// map.put(new Double(fitness), chromo);
 		// }
 		DefaultKeyValue[] keyVals = new DefaultKeyValue[chromosomes.size()];
 
 		for (int i = 0; i < chromosomes.size(); i++) {
 			Chromosome chromo = (Chromosome) chromosomes.get(i);
 			double fitness = adapter.evaluate(chromo);
 			keyVals[i] = new DefaultKeyValue(new Double(fitness), chromo);
 		}
 
 		// Double[] keysList = (Double[]) map.keySet().toArray(
 		// new Double[map.size()]);
 		Arrays.sort(keyVals, new KeyValueComparator());
 
 		NeuralNetwork[] res = new NeuralNetwork[Math
 				.min(keyVals.length, amount)];
 
 		for (int i = 0; i < res.length; i++) {
 			log.debug("Selected chromosome with eval index: " + keyVals[i]);
 			res[i] = adapter.buildNeuralNetworkFromChromosome((Chromosome)keyVals[i].getValue());
 		}
 
 		return res;
 	}
 
 	private class KeyValueComparator implements Comparator {
 
 		public int compare(Object arg0, Object arg1) {
 			double a = ((Double) ((KeyValue) arg0).getKey()).doubleValue();
 			double b = ((Double) ((KeyValue) arg1).getKey()).doubleValue();
 			if (a == b) {
 				return 0;
 			}
 			if (a > b) {
 				return 1;
 			}
 			return -1;
 		}
 
 	}
 }