/***************************************************
  Starter code for CS182 Part2
  Assignment 4: Backpropagation
  Net.java
  **************************************************/

/** 
 * Class implementing a basic three-layer neural network.
 */
public class Net {

  // All initial weights in the network range from -1 to 1.
  static double MIN_WEIGHT = -1.0;
  static double MAX_WEIGHT = 1.0;

  // training parameters (with some defaults)
  static double learningRate = 0.1;
  static double momentum = 0.1;	
  static double errorCriterion = .1;	// error threshold for training to stop
  int numEpochs = 10000;	// number of epochs before training stops
				// (unless error drops below threshold)
  int curEpochs;
	
  int[][] trainingData;
  int[][] trainingTargets;

  Unit Bias;
  Unit inUnit1;
  Unit inUnit2;
  Unit outUnit;
  
  // other Net attributes
  // ** to be filled in (required) **

  /** 
   * Constructor for Net class.
   *
   * Create Net with the specified architecture and data.
   * 
   * @param patterns Array of input patterns (each an array of int)
   * @param targets Array of output patterns (each an array of int)
   */
  public Net (int[][] patterns, int[][] targets) {
  	this.trainingData = patterns;
  	this.trainingTargets = targets;
  	
  	// The Bias is implemented as a unit connected directly to every none input node.
  	// The bias node will always be active, and have no incomming connections.
  	Bias = new Unit();
  	Bias.activation = 1.0;
  	
 	inUnit1 = new Unit();
 	inUnit2 = new Unit();
 	outUnit = new Unit();
 	inUnit1.setOutgoingUnit(outUnit);
 	inUnit2.setOutgoingUnit(outUnit);
 	outUnit.addIncomingUnit(inUnit1);
 	outUnit.addIncomingUnit(inUnit2);
 	outUnit.addIncomingUnit(Bias);
 	
 	outUnit.initialize();
  }

  /**
   * feedforward()
   *
   * @param pattern An input training pattern
   *
   * Present pattern and compute activations for rest of net.
   */
  public void feedforward(int[] pattern) {
 	inUnit1.activation = pattern[0];
 	inUnit2.activation = pattern[1];
 	outUnit.computeActivation();
  }

  /** 
   * computeError()
   *
   * @return current network error
   * 
   * Present all patterns to network and calculate current error.
   * Current error is measured by sum of squared error on output nodes.
   */
  public double computeError() {
  	double sumSqrError = 0;
  	for(int i=0; i<trainingData.length; i++) {
  		feedforward(trainingData[i]);
  	    outUnit.computeError(trainingTargets[i][0]);
  	    sumSqrError += 0.5 * outUnit.error * outUnit.error;
  	}
  	return sumSqrError;
  }

  /**
   * train()
   *
   * Train the net according to the current training parameters.
   *
   * Initialize weights and present patterns in order, updating
   * weights after each pattern.  Training continues until error falls
   * below criterion, or when numEpochs epochs have elapsed, whichever
   * comes first. */
  public void train() {
  	int i;
  	double curError;
  	
 	outUnit.initialize();
 	curError = computeError();
 	for(curEpochs = 1; curEpochs < numEpochs && curError > errorCriterion; curEpochs ++) {
 	 	for(i=0; i<trainingData.length; i++) {
 	  		feedforward(trainingData[i]);
 	  	    outUnit.computeError(trainingTargets[i][0]);
 	  	    outUnit.computeWeightChange();
 		  	outUnit.updateWeights();
	 	}
		curError = computeError();
 	 	if(curEpochs%1000 == 0) { // some useful output
 	 		 System.out.print(computeError());
 	 	}
 	}
  }

  /**
   * toString()
   *
   * A method to neatly dump the weights of each link
   */
  public String toString() {
  	String rStr = "\n";
  	rStr += "Error: " + computeError() + " at epoch " + curEpochs + "\n";
  	rStr += "Weights: \n";
 	rStr += "   inUnit1 -> outUnit = " + outUnit.inWeights[0] + "\n";
 	rStr += "   inUnit2 -> outUnit = " + outUnit.inWeights[1] + "\n";
 	rStr += "   bias -> outUnit = " + outUnit.inWeights[2] + "\n";
 	return rStr;
  }

  
  /**
   * Set network training parameters.
   */
  public void setTrainingParameters(int n, double l, double m, double e) {
    numEpochs = n;
    learningRate = l;
    momentum = m;
    errorCriterion = e;
  }
}