from org.joone.engine import NeuralNetListener
from org.joone.engine import SigmoidLayer,FullSynapse,Monitor 
from org.joone.io import MemoryOutputSynapse,MemoryInputSynapse
from org.joone.engine.learning import TeachingSynapse
from org.joone.net import NeuralNet
from java.lang import System
from jhplot  import *

class joone(NeuralNetListener):

  mills=0
  nnet = NeuralNet()
  epochs=1000
  c1 = SPlot()
  c1.visible()
  c1.setAutoRange()
  c1.setMarksStyle('various')
  c1.setConnected(1, 0)
  c1.setNameY('Global Error')
  c1.setNameX('Epoch') 

  def Go(self,epochs,inputArray,desiredOutput):
     self.epochs=epochs
     print "Running NN for ", epochs, " epochs"
     # First, creates the three Layers
     input=SigmoidLayer()
     hidden=SigmoidLayer()
     output=SigmoidLayer()

     input.setLayerName("input")
     hidden.setLayerName("hidden")
     output.setLayerName("output")

     input.setRows(2)
     hidden.setRows(3)
     output.setRows(1)
     synapse_IH = FullSynapse() # input -> hidden conn. 
     synapse_HO = FullSynapse() # hidden -> output conn. 
     synapse_IH.setName("IH")
     synapse_HO.setName("HO")

     # Connect the input layer with the hidden layer
     input.addOutputSynapse(synapse_IH)
     hidden.addInputSynapse(synapse_IH)

     # Connect the hidden layer with the output layer
     hidden.addOutputSynapse(synapse_HO)
     output.addInputSynapse(synapse_HO)

     inputStream = MemoryInputSynapse() # input array 
     inputStream.setInputArray(inputArray)
     inputStream.setAdvancedColumnSelector("1-2") # The first two columns contain the input 

     desiredOutputSynapse = MemoryInputSynapse() # desired  
     desiredOutputSynapse.setInputArray(desiredOutput)
     desiredOutputSynapse.setAdvancedColumnSelector("1")

     # set the input data
     input.addInputSynapse(inputStream)

     trainer = TeachingSynapse()
     trainer.setDesired(desiredOutputSynapse)
     output.addOutputSynapse(trainer) # Connects the Teacher to the last layer 

     # Creates a new NeuralNet. All the layers must be inserted 
     self.nnet.addLayer(input, NeuralNet.INPUT_LAYER)
     self.nnet.addLayer(hidden, NeuralNet.HIDDEN_LAYER)
     self.nnet.addLayer(output, NeuralNet.OUTPUT_LAYER)
     mon = self.nnet.getMonitor()
     mon.setTrainingPatterns(len(inputArray))  # of rows (patterns) contained in the input file
     mon.setTotCicles(self.epochs)             # How many times the net must be trained on the input patterns        
     mon.setLearningRate(0.7)
     mon.setMomentum(0.6)
     mon.setLearning(True)          #  The net must be trained
     mon.setSingleThreadMode(True)  #  Set to false for multi-thread mode
     #The application registers itself as monitor's listener so it can receive
     #the notifications of termination from the net. */
     mon.addNeuralNetListener(self)
     self.mills = System.currentTimeMillis()
     self.nnet.randomize(0.5)
     self.nnet.go(True)  #  The net starts in non async mode

  def netStopped(self,e):
      delay = System.currentTimeMillis() - self.mills
      print "Training finished after ",delay," ms"

  def cicleTerminated(self,e):
      pass 

  def netStarted(self,e):
      pass 
    
  def errorChanged(self,e):
       mon = e.getSource() 
       c = self.epochs-mon.getCurrentCicle()
       cl = c / 1000
       if ((cl * 1000) == c): 
           err=mon.getGlobalError()
           print c," epoch RMSE = ", err 
           self.c1.addPoint(0,c,err,1)
           self.c1.update()
 
  def netStoppedError(self,e):
       pass 

  def getPredict(self,inputArray):
      input = self.nnet.getInputLayer()
      input.removeAllInputs()
      nsize=len(inputArray)
      memInp =  MemoryInputSynapse()
      memInp.setFirstRow(1)
      memInp.setAdvancedColumnSelector("1,2")
      input.addInputSynapse(memInp)
      memInp.setInputArray(inputArray)
      output = self.nnet.getOutputLayer()
      output.removeAllOutputs()
      memOut = MemoryOutputSynapse()
      output.addOutputSynapse(memOut)
      self.nnet.getMonitor().setTotCicles(1)
      self.nnet.getMonitor().setTrainingPatterns(nsize)
      self.nnet.getMonitor().setLearning(False)
      self.nnet.go(True)  #  The net starts in non async mode
      pred=[]
      for i in range(nsize):
           pattern = memOut.getNextPattern()
           # print "Predicted Pattern #",(i+1)," = ",pattern[0]
           pred.append(pattern[0])
      return pred
 
inputArray=[[0.0, 0.0],[0.0, 1.0],[1.0, 0.0],[1.0, 1.0]]
desiredOutput=[[0],[1],[1],[0]]

xor=joone()
xor.Go(20000,inputArray,desiredOutput)
print "Stop. Get predictions"
pred=xor.getPredict(inputArray)
for i in range(len(inputArray)):
    print inputArray[i],"predicted=",pred[i], " expected=",desiredOutput[i]