RNA - Aprender un numero digital

RNA - Aprender un numero digital

Con la plantilla utilizada para construir una red neuronal de la entrada anterior, la modificaremos  para el siguiente modelo:

Ahora la capa "K" tiene 4 nodos(neuronas) con 5 entradas más una entrada del Bias(entrada de otra neurona como parte de una red) , así tendría 6 entradas para cada nodo "K". Para la capa "J" tenemos 5 nodos con 7 entradas más una entrada como "bias" , lo que suma 8 entradas para cada nodo de la capa "J".

                   Numero        Representación digital          Representación Binaria
                      0                      1  1  1  0  1  1  1                        0  0  0  0  0
                      1                      1  0  0  0  0  0  1                        0  0  0  0  1
                      2                      1  1  0  1  1  1  0                        0  0  0  1  0
                      3                      1  1  0  1  0  1  1                        0  0  0  1  1
                      4                      1  0  1  1  0  0  1                        0  0  1  0  0
                      5                      0  1  1  1  0  1  1                        0  0  1  0  1
                      6                      0  1  1  1  1  1  1                        0  0  1  1  0
                      7                      1  1  0  0  0  0  1                        0  0  1  1  1
                      8                      1  1  1  1  1  1  1                        1  0  0  0  0
                      9                      1  1  1  1  0  1  1                        1  0  0  0  1

La representación digital serán la entradas junto a un balance del "bias"(en este caso -1) y la representación binaria es lo que la red debe aprender

public class TestNumero {                            //NK NJ EK EJ
    static RedNeuronal1 redNeuronal = new RedNeuronal1( 4, 5, 6, 8);
    static double balance = -1;                      
    static double[][] capaI = {{1,1,1,0,1,1,1,balance},  //0
                 {1,0,0,0,0,0,1,balance},  //1
                               {1,1,0,1,1,1,0,balance},  //2
                               {1,1,0,1,0,1,1,balance},  //3
       /*rep. digital*/        {1,0,1,1,0,0,1,balance},  //4
                               {0,1,1,1,0,1,1,balance},  //5
                               {0,1,1,1,1,1,1,balance},  //6
                               {1,1,0,0,0,0,1,balance},  //7
                               {1,1,1,1,1,1,1,balance},  //8
                               {1,1,1,1,0,1,1,balance}}; //9
    static double[][]  aprender =  {{0,0,0,0,0,0,0,0,1,1},
        {0,0,0,0,1,1,1,1,0,0},
                                    {0,0,1,1,0,0,1,1,0,0},
                                    {0,1,0,1,0,1,0,1,0,1}}; 
                                  //0  1 2 3 4 5 6 7 8 9    rep. binaria

Descargar archivo con frame para aprender un numero digital.
Descargar plantilla RNA

RNA - Aprender si un cuadrado es par

Definiremos los cuadrados impares, y definiremos a la cantidad impar con el valor de " 0 ".

Solo será par cuando dos casillas estén pintadas y tendrá el valor de " 1 ". No estarán definidas el cuadro sin pintar ni el cuadro con todas las casillas pintadas.

Cada nodo posee un vector de entradas(en este caso son 5 para la capa J y 3 para la capa K), y cada entrada tiene un peso("inicialmente aleatorios") y un función de activación(en este ejemplo sera la funcion sigmoidal).

También para cada nodo tendremos un error , utilizaremos el entrenamiento Backpropagation .

Construimos la clase nodo("neuron1")

package parimparrn;

public class Neuron1 {
    private double activacionu;
 double [] entradas;
 double [] pesos;
 double errorNodo;
 static Sigmoide sigmoide;
        public Neuron1(int nentradas)
 {
  pesos = new double[nentradas];
  entradas = new double[nentradas];
  sigmoide = new Sigmoide();
  errorNodo = 0;
 }
 public void activacion()
 {
  double suma = 0;
  for(int i=0;i<entradas.length;i++)
  {
   suma =suma + entradas[i]*pesos[i];
  }
  activacionu = sigmoide.funcion(suma);
 }

    public double[] getEntradas() {
        return entradas;
    }

    public void setEntradas(double[] entradas) {
        this.entradas = entradas;
    }

    public double[] getPesos() {
        return pesos;
    }

    public void setPesos(double[] pesos) {
        this.pesos = pesos;
    }
 public void verEntradas()
 {
  System.out.print(" entradas  ");
  for(int i=0;i<entradas.length;i++)
  {
   System.out.println(entradas[i]);
  }
 }
 public void verPesos()
 {
  System.out.println(" *** pesos ** ");
  for(int i=0;i<pesos.length;i++)
  {
   System.out.println(""+pesos[i]);
  }
 }
 public double getActivacion()
 {
  return activacionu;
 }
 public void verActivacion()
 {
  System.out.println("activacion");
  System.out.println(""+activacionu);
 }
 public double getError()
 {
  return errorNodo;
 }
 public void setError(double error)
 {
  errorNodo=error;
 }
        
}

Adjunto el proyecto , el archivo con frame , utiliza los pesos aprendidos tras ejecutar el método run de la clase TestRN.En  el proyecto sin frame se ejecuta el método y se encuentra los pesos para la red.
Descargar Proyecto completo con frame
Descargar Proyecto completo sin frame
Descargar  plantillas de RNA