Source code: AI/NeuralNetworks/DistributedBackErrorPropagation.java

   /* DistributedBackErrorPropagation.java */
   
   package AI.NeuralNetworks;
   
   import java.util.*;
   import java.net.*;
   import java.io.*;
   //import MPI.*;
   
  /** 
    This Class is a nerual network with a multiple layer feed forward architecture where
    a distributed version of the back error propagation algorithm could be run
  */
  public class DistributedBackErrorPropagation extends BackErrorPropagation implements NeuralNetworkTeacher{
  //  protected boolean master;
    protected Set hosts;
    protected Socket sock;
    
    protected BufferedWriter bw;
    
  //  protected int rootProcess = 0;
  //  protected Comm communicator;
    
  //  public static int ROOT = 0;
  //  public static String LOAD_STRUCTURE = "";
    
  
    /**
     Creates a new DistributedBackErrorPropagation instance
     */
    public DistributedBackErrorPropagation(FeedForwardNetwork network, BufferedWriter bw){
      ListIterator originalNet;
      
      layers = new LinkedList();
      
      originalNet = network.layers.listIterator();
      layers.add(new FeedForwardInputLayer((FeedForwardInputLayer) originalNet.next()));
      while(originalNet.hasNext()){
        layers.add(new DistributedFeedForwardWeightedTrainingLayer((FeedForwardWeightedLayer) originalNet.next() /*, communicator, rootProcess*/  ));
      }
      this.bw = bw;
    }
  
    /**
     Creates a new DistributedBackErrorPropagation instance
     */
    public DistributedBackErrorPropagation(FeedForwardNetwork network){
      this(network, null);
    }
    /**
     Trains the network with the  given patterns
     @param patterns are the pairs of input-expected output that the network must learn
     */
    public float trainNetwork(LinkedList trainingPatterns) throws UnexpectedInputArraySizeException{
      ListIterator patternList;
      PatternPair pattern;
      float[] outputError;
  //    int epoch=0;
      float error = 0;
  //    float[] tempError = new float[1];
          
      patternList = trainingPatterns.listIterator(0);
      
      resetDeltaWeights();
      error = 0;
      
  //System.out.println(this.toString());    
      
      while(patternList.hasNext()){
        pattern = (PatternPair) patternList.next();
      
  //        System.out.println("\t"+r+"\tepoch: "+epoch+"\tpattern: "+niceArray(pattern.input())); //debug 
        adjustDeltaWeights(pattern.input(), pattern.output());
  
        outputError = ((FeedForwardWeightedTrainingLayer) layers.getLast()).getOutputError();
        for (int e=0; e<outputError.length; e++){
          error += outputError[e] * outputError[e];
  //System.out.println("errorAcum " + error );
        }
      }
  //    outputError = ((FeedForwardWeightedTrainingLayer) layers.getLast()).getError();
  //    tempError[0] = error;
  //    tempError = communicator.AllReduceSumFloat(tempError, rootProcess);
  //    error = (float) Math.sqrt(Math.abs(tempError[0] / (trainingPatterns.size() * outputError.length)));
  
  //    addDeltaWeights();      
  
      sendError(error);
  //System.out.println("errorSend " + error );
      sendDeltaWeights();      
          
      return error;
    }
    
    public void sendError(float error){
      try{
        /**/
        int errorBits = Float.floatToIntBits(error);
        bw.write( errorBits & 0x000000ff);
       bw.write((errorBits & 0x0000ff00) >>>8);
       bw.write((errorBits & 0x00ff0000) >>>16);
       bw.write((errorBits & 0xff000000) >>>24);
 //System.out.println("sendError = "+ error);//debug      
       /**/
       //bw.write(""+error); // cambiar aca que manda el error como String
       //bw.newLine();
       bw.flush();
     } catch (IOException ioe) {
       ioe.printStackTrace();
     }
   }
   
   public void sendDeltaWeights(){// cambiar aca que manda los pesos como String
     ListIterator layer;
     
     layer = layers.listIterator(1); //the first layer does not have weights
     
     while(layer.hasNext()){
       ((DistributedFeedForwardWeightedTrainingLayer) layer.next()).sendDeltaWeights(bw);
     }    
   }
   
   /**
     Adds the all deltaWeights to the weights
   */
   public void addDeltaWeights(){
     ListIterator layer;
     
     layer = layers.listIterator(1); //the first layer does not have weights
     
     while(layer.hasNext()){
       ((DistributedFeedForwardWeightedTrainingLayer) layer.next()).addDeltaWeights(learningRate);
     }
   }  
   
   /**
     adds the delta weights form br to the local delta weights
   */
   public void parseDeltaWeights(BufferedReader br){
     ListIterator layer;
     
     layer = layers.listIterator(1); //the first layer does not have weights
     
     while(layer.hasNext()){
       ((DistributedFeedForwardWeightedTrainingLayer) layer.next()).parseDeltaWeights(br);
     }
   }
   
   
   
   static private String niceArray(float array[]){
     String s = "[ ";
     for(int i=0; i<array.length; i++){
       s += array[i] + " ";
     }
     s+= "]";
     return s;
   }
   static private String niceArray(int array[]){
     String s = "[ ";
     for(int i=0; i<array.length; i++){
       s += array[i] + " ";
     }
     s+= "]";
     return s;
   }
   
   static private void showList(LinkedList pat){ //debug
     ListIterator li = pat.listIterator(0);
     
     while(li.hasNext()){
       System.out.println(((PatternPair) li.next()).toString());
     }
   
   }
 
 }