Pastebin launched a little side project called VERYVIRAL.com, check it out ;-) Want more features on Pastebin? Sign Up, it's FREE!

PerceptronSimple

By: mcarcini on Feb 23rd, 2013  |  syntax: Java  |  size: 9.60 KB  |  views: 1,425  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. import java.awt.event.ActionEvent;
  2. import java.awt.event.ActionListener;
  3. import javax.swing.JOptionPane;
  4. import javax.swing.*;
  5. import java.math.BigDecimal;
  6. import java.math.RoundingMode;
  7.  
  8.  
  9. public class PerceptronSimple implements ActionListener{
  10.      
  11.     JButton entrenar=new JButton("ENTRENAR");
  12.     JMenuBar menu=new JMenuBar();
  13.     JMenu compuertasLogicas=new JMenu("ELEGIR COMPUERTA LOGICA");    
  14.     JMenuItem and=new JMenuItem("AND");
  15.     JMenuItem or=new JMenuItem("OR");
  16.     JButton probar=new JButton("PROBAR");
  17.     ImageIcon icono=new ImageIcon("perceptronsimple.png");
  18.     JLabel imagen=new JLabel(icono);
  19.    
  20.     static float funcionActivacion=0.0f;    
  21.     static float error=1.0f;
  22.     int iteraciones = 0;
  23.     static float[][] entradas =    
  24.         {
  25.                 //Entrada 1, Entrada 2, Umbral
  26.                 //  {x1 , x2  , -1 }
  27.                
  28.             {1f , 1f  , -1f},    
  29.             {1f , -1f , -1f},
  30.             {-1f, 1f  , -1f},
  31.             {-1 , -1f , -1f}      
  32.         };            
  33.      // salidasDeseadas para el perceptron                            
  34.      float[] salidasDeseadas=new float[4];
  35.      int establecioSalidas=0;
  36.      static float[] pesos = {1.2f,-1.2f,-0.4f};
  37.      static float factorAprendizaje=.5f;
  38.        
  39.      public static void main(String args[]){
  40.         new PerceptronSimple();
  41.     }
  42.     PerceptronSimple(){
  43.         JFrame ventana=new JFrame();
  44.         ventana.setVisible(true);
  45.         ventana.setSize(500,300);
  46.         ventana.setDefaultCloseOperation(ventana.EXIT_ON_CLOSE);
  47.         ventana.setTitle("PERCEPTRON SIMPLE");
  48.         ventana.setResizable(false);
  49.         ventana.setLocationRelativeTo(null);
  50.         JDesktopPane esc=new JDesktopPane();
  51.         //les asignamos una posicion a los componentes
  52.         entrenar.setBounds(140,220,100,20);
  53.         probar.setBounds(260,220,100,20);        
  54.         imagen.setBounds(5,10,500,250);
  55.        
  56.         //ponemos a escuchar por algun evento a los botones y menuitem
  57.         entrenar.addActionListener(this);        
  58.         probar.addActionListener(this);
  59.         or.addActionListener(this);
  60.         and.addActionListener(this);
  61.        
  62.         //agregamos los 2 menuitem al menu
  63.         compuertasLogicas.add(and);
  64.         compuertasLogicas.add(or);
  65.         //agregamos el menu al menubar
  66.         menu.add(compuertasLogicas);
  67.         //agregamos todos los componentes al escritorio
  68.         esc.add(entrenar);
  69.         esc.add(probar);      
  70.         esc.add(imagen);
  71.         //indicamos cual es el menu y agreamos el escritorio a la ventana
  72.         ventana.setJMenuBar(menu);
  73.         ventana.add(esc);                    
  74.     }    
  75.      @Override
  76.     public void actionPerformed(ActionEvent e){
  77.         if(e.getSource()==entrenar){            
  78.             if(establecioSalidas==0){
  79.                JOptionPane.showMessageDialog(null,"Primero eliga la compuerta logica que debera aprender el perceptron");  
  80.             }else{
  81.                System.out.println("Pesos Iniciales");
  82.                            //imprimimos los pesos que definimos anteriormente
  83.                for(int i = 0; i < pesos.length; i++){
  84.                  System.out.println(pesos[i]);
  85.                }
  86.                System.out.println("");        
  87.                int contador = 0;        
  88.                            /*recorremos las entradas y se le van pasando a la funcionActivacion() esta funcion nos regresa la salida para dichas entradas.
  89.                              por ejemplo si elegimos la compuerta OR y se le manda la entradas:
  90.                              x1 = 1  , x2 = 0 la salida que nos deberia de regresa la funcionActivacion() es 1 esta salida se le manda
  91.                              al metodo error este verifica si hay o no error
  92.                            */
  93.                for(int i = 0; i <= entradas[0].length; i++){
  94.                  System.out.println("ITERACION "+contador+":");
  95.                  float funcionActivacion = funcionActivacion(entradas[i]);
  96.                  System.out.println("activacion: "+funcionActivacion);
  97.                  float error = error(salidasDeseadas[i]);
  98.                  System.out.println("Error: "+error);
  99.                  if(error==0f){      
  100.                                    //Entra aqui si no hay error
  101.                    System.out.println("--------------------------------------");
  102.                    contador++;    
  103.                  }else{
  104.                     //Si hay error, recalcula los pesos
  105.                     calculaPesos(entradas[i],salidasDeseadas[i]);
  106.                     /*ponemos i=-1 para que empiece a sacar la funcion
  107.                     de activacion  desde el inicio  con los nuevos pesos*/
  108.                     i=-1;                      
  109.                     contador = 0;  
  110.                  }
  111.                }
  112.                JOptionPane.showMessageDialog(null,"LA RED YA ESTA ENTRENADA");              
  113.                System.out.println("Pesos Finales");
  114.                for(int i = 0; i < pesos.length; i++){
  115.                  System.out.println(pesos[i]);
  116.                }
  117.        
  118.            }                                      
  119.                  // ya una ves que el perceptron este entrenado podemos dar clic en el boton probar y nos ira pidiendo las entradas
  120.                  // y nos debera de dar la salida correcta para cada entrada
  121.         }else if(e.getSource()==probar){                                                                      
  122.               String x1=JOptionPane.showInputDialog(null,"Ingresa la primera entrada");                      
  123.               String x2=JOptionPane.showInputDialog(null,"Ingresa la segunda entrada");                      
  124.               float [] entradasPrueba=new float[3];
  125.               entradasPrueba [0]=Float.parseFloat(x1); //entrada neurona 1
  126.               entradasPrueba [1]=Float.parseFloat(x2); //entrada neurona 2
  127.               entradasPrueba [2]=-1f;                  //entrada para el umbral
  128.               float resultado = probarRed(entradasPrueba);              
  129.               JOptionPane.showMessageDialog(null,resultado);
  130.           }
  131.         if(e.getSource()==or){
  132.                  // definimos las salidas deseadas para la compuerta logica or
  133.           salidasDeseadas[0]=1f;
  134.           salidasDeseadas[1]=1f;
  135.           salidasDeseadas[2]=1f;
  136.           salidasDeseadas[3]=-1f;          
  137.           establecioSalidas=1;
  138.        }
  139.         if(e.getSource()==and){
  140.                 // definimos las salidas deseadas para la compuerta logica and
  141.           salidasDeseadas[0]=1f;
  142.           salidasDeseadas[1]=-1f;
  143.           salidasDeseadas[2]=-1f;
  144.           salidasDeseadas[3]=-1f;          
  145.           establecioSalidas=1;
  146.         }
  147.     }  
  148.      
  149.      public static float funcionActivacion(float[] entradas){
  150.         funcionActivacion = 0.0f;
  151.         System.out.println("metodo funcionActivacion");
  152.         for(int i = 0; i < entradas.length; i++){
  153.            
  154.             // se multiplica cada peso por cada entrada y se suma
  155.             funcionActivacion += pesos[i] * entradas[i];
  156.            
  157.             //redondeamos a 2 decimales el valor de la funcion activacion
  158.             String val = funcionActivacion+"";
  159.             BigDecimal big = new BigDecimal(val);
  160.             big = big.setScale(2, RoundingMode.HALF_UP);    
  161.             funcionActivacion=big.floatValue();
  162.             System.out.println("Multiplicacion");
  163.             System.out.println("w"+i+" * "+"x "+i);
  164.             System.out.println(pesos[i] +"*" +entradas[i]);
  165.            
  166.         }
  167.         System.out.println("y = "+funcionActivacion);
  168.         //se determina el valor de la salida
  169.         if(funcionActivacion >= 0)
  170.             funcionActivacion = 1;
  171.         else if(funcionActivacion < 0)
  172.             funcionActivacion = -1;
  173.        
  174.         return funcionActivacion;
  175.     }
  176.      //metodo para verificar si hay o no error
  177.         public static float error(float salidaDeseada){
  178.           System.out.println("Salida deseada - salida");
  179.           error = salidaDeseada - funcionActivacion;
  180.           System.out.println(salidaDeseada+" - "+funcionActivacion);
  181.           return error;
  182.         }
  183.       //metodo para el reajuste de pesos
  184.     public void calculaPesos(float[] entradas,float salidas){
  185.      if(error != 0){            
  186.        for(int i = 0; i < entradas.length; i++){                
  187.          System.out.println(pesos[i]+" + (2 * .5) * "+salidas+" * "+entradas[i]);                              
  188.          this.pesos[i]=pesos[i]+(2.0f*.5f)*(salidas*entradas[i]);                  
  189.          String val = this.pesos[i]+"";
  190.          BigDecimal big = new BigDecimal(val);
  191.          big = big.setScale(2, RoundingMode.HALF_UP);    
  192.          funcionActivacion=big.floatValue();                
  193.          System.out.println("salida");
  194.          System.out.println("AHORA LOS PESOS CAMBIARON A :"+ this.pesos[i]);
  195.             }
  196.         }
  197.     }        
  198.       public float probarRed(float [] entradasPrueba){
  199.         float result;        
  200.         funcionActivacion = 0.0f;
  201.         System.out.println("----------PROBANDO EL PERCEPTRON ---------");
  202.         for(int i = 0; i <=2 ; i++){
  203.             funcionActivacion += pesos[i] * entradasPrueba[i];            
  204.             String val = funcionActivacion+"";
  205.             BigDecimal big = new BigDecimal(val);
  206.             big = big.setScale(2, RoundingMode.HALF_UP);    
  207.             funcionActivacion=big.floatValue();
  208.             System.out.println("Multiplicacion");
  209.             System.out.println("w"+i+" * "+"x "+i);
  210.             System.out.println(pesos[i] +"*" +entradasPrueba[i]);
  211.         }
  212.         System.out.println("y = "+funcionActivacion);        
  213.          if(funcionActivacion >= 0)
  214.             funcionActivacion = 1;
  215.         else if(funcionActivacion < 0)
  216.             funcionActivacion = -1;
  217.          
  218.         result=funcionActivacion;        
  219.         return result;
  220.     }
  221.  
  222. }