Código Java

Una forma sencilla y rápida de aprender JAVA, observando y deduciendo cómo se comporta el lenguaje a través de ejemplos prácticos.

domingo, 19 de noviembre de 2017

Creación de una estructura de red neuronal artificial perceptrón multicapa.

Se trata de que a partir de un vector se cree una estructura neuronal artificial basada en capas (perceptrón multicapa).
El funcionamiento es que los valores introducidos en el vector indican el número de neuronas que tiene cada capa, y la posición o el índice de estos valores corresponde a la capa a la que se aplica.

Ejemplo:

Con el vector {2, 3, 3, 1} la red tendría la siguiente estructura:




En el ejemplo también se agregan los pesos(w) de las conexiones y se calculan todas las salidas de las neuronas(s). El cálculo de las salidas se le llama "propagación hacia delante".


* Nomenclatura de los pesos(w):

w[k][j][i]

k = índice capa
j = índice conector origen
i = índice conector destino


* Nomenclatura de las salidas(s):

s[k][j]

k = índice capa
j = índice neurona

En última instancia se calcula el error, teniendo como referencia la salida deseada (d1) en contraste con la salida real.


Código1 (Red.java):

package red;
public class Red {
   public static void main(String[] args) {
      Estructura red = new Estructura();
      red.estruct();
   }
}


Código2 (Estructura.java):

package red;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;

public class Estructura {

   int nK[] = {2, 3, 3, 1};
   double[][][] w = new double[nK.length][9][9]; //peso
   double[][] s = new double[nK.length][9]; //salida

   // tabla de entrenamiento
   final int x1[] = {34}; // entrada 1 (x1)
   final int x2[] = {23}; // entrada 2 (x2)
   final int d1[] = {57}; // salida deseada 1 (d1)

   public void estruct() {

      int row = 1;
      for (int i = 0; i < nK.length; i++) {
         row *= nK[i];
      }

      // inicializar vector con pesos aleatorios.
      double[] vw = new double[row];
      for (int i = 0; i < vw.length; i++) {
         vw[i] = new Random().nextDouble();
      }

      // Añadir los pesos(w) y cálculo salidas(s) - Propagación hacia delante -
      propagacion_hacia_delante(vw);

   }

   private void propagacion_hacia_delante(double[] vw) {

      // vector a lista  
      List<Double> lw = new ArrayList<>();
      for (int i = 0; i < vw.length; i++) {
         lw.add(vw[i]);
      }
      Iterator wi = lw.iterator();

      System.out.println("* Entradas (x1, x2): ");
      int k = 0;
      s[k][0] = x1[0] / 100.0;
      s[k][1] = x2[0] / 100.0;
      System.out.println("s[" + k + "][" + 0 + "] = " + s[k][0]);
      System.out.println("s[" + k + "][" + 1 + "] = " + s[k][1]);
      double aux;
      for (k = 1; k < nK.length; k++) {
         System.out.println("\n* Capa(k): " + k);
         for (int j = 0; j < nK[k]; j++) {
            aux = 0.0;
            for (int i = 0; i < nK[k - 1]; i++) {
               if (wi.hasNext()) {
                  w[k][j][i] = (double) wi.next();
                  System.out.println("w[" + k + "][" + j + "][" + i + "] = " + w[k][j][i]);
                  aux += s[k - 1][i] * w[k][j][i];
               }
            }
            s[k][j] = F(aux);
            System.out.println("s[" + k + "][" + j + "] = " + s[k][j]);
            System.out.println("");
         }
      }

      double error = error(s[nK.length - 1][0]);
      System.out.println("Error(%) = " + error + "\n");

   }

   // cálculo error
   private double error(double salida) {
      System.out.println("\nCalculando error: ");
      System.out.println("Salida real (s) = " + salida);
      System.out.println("Salida deseada (d1) = " + d1[0] / 100.0);
      double error = (d1[0] / 100.0) - salida;
      return Math.abs(error) * 100.0;
   }

   // función de activación(F)
   public double F(double n) {
      return 1 / (1 + Math.pow(Math.E, -n));
   }

}


Resultado:

run:

* Entradas (x1, x2):
s[0][0] = 0.34
s[0][1] = 0.23

* Capa(k): 1
w[1][0][0] = 0.7784702928226366
w[1][0][1] = 0.6257786601112015
s[1][0] = 0.6007542942239193

w[1][1][0] = 0.5968623640712245
w[1][1][1] = 0.6454353802610788
s[1][1] = 0.5869529953218492

w[1][2][0] = 0.6365114581851211
w[1][2][1] = 0.5225522235927118
s[1][2] = 0.5833646070992183


* Capa(k): 2
w[2][0][0] = 0.8144433731113941
w[2][0][1] = 0.3745491950410721
w[2][0][2] = 0.8572794764916719
s[2][0] = 0.7701626126927235

w[2][1][0] = 0.7461525150108156
w[2][1][1] = 0.016718260683668218
w[2][1][2] = 0.7820072960095001
s[2][1] = 0.7138716176876397

w[2][2][0] = 0.6111430308203408
w[2][2][1] = 0.471402921978638
w[2][2][2] = 0.36959971608321707
s[2][2] = 0.7025456368129452


* Capa(k): 3
w[3][0][0] = 0.5283695321605173
w[3][0][1] = 0.14549272162478644
w[3][0][2] = 0.27585354985756827
s[3][0] = 0.6692053761568678


Calculando error:
Salida real (s) = 0.6692053761568678
Salida deseada (d1) = 0.57
Error(%) = 9.920537615686786

BUILD SUCCESSFUL (total time: 0 seconds)


Con la tecnología de Blogger.