/**
    * Copyright (c) 2011, The University of Southampton and the individual contributors.
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without modification,
    * are permitted provided that the following conditions are met:
    *
    *   * 	Redistributions of source code must retain the above copyright notice,
    * 	this list of conditions and the following disclaimer.
   *
   *   *	Redistributions in binary form must reproduce the above copyright notice,
   * 	this list of conditions and the following disclaimer in the documentation
   * 	and/or other materials provided with the distribution.
   *
   *   *	Neither the name of the University of Southampton nor the names of its
   * 	contributors may be used to endorse or promote products derived from this
   * 	software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
   * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
   * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package org.openimaj.ml.neuralnet;
  
  import gnu.trove.map.hash.TIntIntHashMap;
  import gnu.trove.map.hash.TIntObjectHashMap;
  import gnu.trove.procedure.TIntObjectProcedure;
  import gov.sandia.cognition.io.CSVUtility;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.encog.engine.network.activation.ActivationStep;
  import org.encog.mathutil.rbf.RBFEnum;
  import org.encog.ml.MLRegression;
  import org.encog.ml.data.MLDataPair;
  import org.encog.ml.data.MLDataSet;
  import org.encog.ml.data.specific.CSVNeuralDataSet;
  import org.encog.ml.svm.SVM;
  import org.encog.ml.svm.training.SVMTrain;
  import org.encog.ml.train.MLTrain;
  import org.encog.neural.cpn.CPN;
  import org.encog.neural.cpn.training.TrainInstar;
  import org.encog.neural.cpn.training.TrainOutstar;
  import org.encog.neural.data.basic.BasicNeuralData;
  import org.encog.neural.neat.NEATPopulation;
  import org.encog.neural.neat.training.NEATTraining;
  import org.encog.neural.networks.training.CalculateScore;
  import org.encog.neural.networks.training.TrainingSetScore;
  import org.encog.neural.networks.training.propagation.resilient.ResilientPropagation;
  import org.encog.neural.rbf.RBFNetwork;
  import org.encog.util.simple.EncogUtility;
  import org.openimaj.util.pair.IndependentPair;
  
  import Jama.Matrix;
  
  /**
   * @author Sina Samangooei (ss@ecs.soton.ac.uk)
   * 
   *         Just some experiments using the sandia cognitive foundary neural
   *         nets.
   * 
   */
  public class HandWritingNeuralNetENCOG {
  
  	/**
  	 * Default location of inputs
  	 */
  	public static final String INPUT_LOCATION = "/org/openimaj/ml/handwriting/inputouput.csv";
  
  	private int maxTests = 10;
  
  	private TIntIntHashMap examples;
  	private TIntObjectHashMap<List<IndependentPair<double[], double[]>>> tests;
  
  	private int totalTests = 0;
  
  	private MLRegression network;
  
  	private MLDataSet training;
  
  	/**
  	 * @throws IOException
  	 *             Load X input and y output from {@link #INPUT_LOCATION}
 	 */
 	public HandWritingNeuralNetENCOG() throws IOException {
 
 		examples = new TIntIntHashMap();
 		this.tests = new TIntObjectHashMap<List<IndependentPair<double[], double[]>>>();
 		prepareDataCollection();
 		learnNeuralNet();
 		testNeuralNet();
 		// new HandWritingInputDisplay(this.training);
 	}
 
 	private void testNeuralNet() {
 		final double[][] xVals = new double[totalTests][];
 		final int[] yVals = new int[totalTests];
 		this.tests.forEachEntry(new TIntObjectProcedure<List<IndependentPair<double[], double[]>>>() {
 			int done = 0;
 
 			@Override
 			public boolean execute(int number, List<IndependentPair<double[], double[]>> xypairs) {
 				for (final IndependentPair<double[], double[]> xyval : xypairs) {
 					final double[] guessed = network.compute(new BasicNeuralData(xyval.firstObject())).getData(); // estimate
 					int maxIndex = 0;
 					double maxValue = 0;
 					for (int i = 0; i < guessed.length; i++) {
 						if (maxValue < guessed[i])
 						{
 							maxValue = guessed[i];
 							maxIndex = i;
 						}
 					}
 					xVals[done] = xyval.firstObject();
 					yVals[done] = (maxIndex + 1) % 10;
 					done++;
 				}
 				return true;
 			}
 		});
 		new HandWritingInputDisplay(xVals, yVals);
 	}
 
 	private void prepareDataCollection() throws IOException {
 		final File tmp = File.createTempFile("data", ".csv");
 		final InputStream stream = HandWritingNeuralNetENCOG.class.getResourceAsStream(INPUT_LOCATION);
 		final BufferedReader reader = new BufferedReader(new InputStreamReader(stream));
 		String line = null;
 		final PrintWriter writer = new PrintWriter(new FileWriter(tmp));
 		while ((line = reader.readLine()) != null) {
 			writer.println(line);
 		}
 		writer.close();
 		reader.close();
 		training = new CSVNeuralDataSet(tmp.getAbsolutePath(), 400, 10, false);
 		final Iterator<MLDataPair> elementItr = this.training.iterator();
 		for (; elementItr.hasNext();) {
 			final MLDataPair type = elementItr.next();
 			final double[] yData = type.getIdealArray();
 			final double[] xData = type.getInputArray();
 			int yIndex = 0;
 			while (yData[yIndex] != 1)
 				yIndex++;
 			final int currentCount = this.examples.adjustOrPutValue(yIndex, 1, 1);
 			if (currentCount < this.maxTests) {
 
 				List<IndependentPair<double[], double[]>> numberTest = this.tests.get(yIndex);
 				if (numberTest == null) {
 					this.tests.put(yIndex, numberTest = new ArrayList<IndependentPair<double[], double[]>>());
 				}
 				numberTest.add(IndependentPair.pair(xData, yData));
 				totalTests++;
 			}
 		}
 
 	}
 
 	private void learnNeuralNet() {
 		// this.network = EncogUtility.simpleFeedForward(400, 100, 0, 10,
 		// false);
 		// MLTrain train = new Backpropagation(this.network, this.training);
 		// MLTrain train = new ResilientPropagation(this.network,
 		// this.training);
 
 		// this.network = withNEAT();
 		// this.network = withRBF();
 		// this.network = withSVM();
 		this.network = withResilieant();
 		// this.network = withCPN();
 	}
 
 	private MLRegression withNEAT() {
 		final NEATPopulation pop = new NEATPopulation(400, 10, 1000);
 		final CalculateScore score = new TrainingSetScore(this.training);
 		// train the neural network
 		final ActivationStep step = new ActivationStep();
 		step.setCenter(0.5);
 		pop.setOutputActivationFunction(step);
 		final MLTrain train = new NEATTraining(score, pop);
 		EncogUtility.trainToError(train, 0.01515);
 		return (MLRegression) train.getMethod();
 	}
 
 	private MLRegression withResilieant() {
 		final MLTrain train = new ResilientPropagation(EncogUtility.simpleFeedForward(400, 100, 0, 10, false),
 				this.training);
 		EncogUtility.trainToError(train, 0.01515);
 		return (MLRegression) train.getMethod();
 	}
 
 	private MLRegression withSVM() {
 		final MLTrain train = new SVMTrain(new SVM(400, true), this.training);
 		EncogUtility.trainToError(train, 0.01515);
 		return (MLRegression) train.getMethod();
 	}
 
 	private MLRegression withRBF() {
 		final MLRegression train = new RBFNetwork(400, 20, 10, RBFEnum.Gaussian);
 		EncogUtility.trainToError(train, this.training, 0.01515);
 		return train;
 	}
 
 	private MLRegression withCPN() {
 		final CPN result = new CPN(400, 1000, 10, 1);
 		final MLTrain trainInstar = new TrainInstar(result, training, 0.1, false);
 		EncogUtility.trainToError(trainInstar, 0.01515);
 		final MLTrain trainOutstar = new TrainOutstar(result, training, 0.1);
 		EncogUtility.trainToError(trainOutstar, 0.01515);
 		return result;
 	}
 
 	private static <T> ArrayList<T> toArrayList(T[] values) {
 		final ArrayList<T> configList = new ArrayList<T>();
 		for (final T t : values) {
 			configList.add(t);
 		}
 		return configList;
 	}
 
 	private Matrix fromCSV(BufferedReader bufferedReader, int nLines) throws IOException {
 
 		String[] lineValues = null;
 		double[][] outArr = null;
 		Matrix retMat = null;
 		int row = 0;
 		while ((lineValues = CSVUtility.nextNonEmptyLine(bufferedReader)) != null) {
 			if (outArr == null) {
 				retMat = new Matrix(nLines, lineValues.length);
 				outArr = retMat.getArray();
 			}
 
 			for (int col = 0; col < lineValues.length; col++) {
 				outArr[row][col] = Double.parseDouble(lineValues[col]);
 			}
 			row++;
 		}
 		return retMat;
 	}
 
 	public static void main(String[] args) throws IOException {
 		new HandWritingNeuralNetENCOG();
 	}
 }