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.

lunes, 17 de febrero de 2014

Neurona Artificial (V). Puerta lógica XOR.

Esta vez vamos a ver como funciona un sistema neuronal teniendo los pesos ya calibrados especificamente para la resolución de puertas lógicas XOR. El funcionamiento es el siguiente:



























Voy a utilizar la notación bipolar(1,-1), que es la más usada en las redes neuronales artificiales por varias razones de peso y es que tiene un rango mayor, es más eficiente y más preciso que la notación binaria(0,1). Para la resolución del problema he elegido el Perceptrón Multicapa siguiente:
























He puesto dos neuronas en la capa oculta siguiendo una regla que suele dar buenos resultados que es la de multiplicar el número de entradas por el número de neuronas de salida, y así obtenemos el número de neuronas a poner en la capa central (llamada oculta):
 
H = N * M
H = 2 * 1
H = 2

N = Número de Entradas (2)
M = Número de Neuronas de Salida (1)
H = Número de Neuronas de la Capa Oculta.

Y un último detalle es la nomenclatura que suele utilizarse para identificar los pesos de una red neuronal:

















En el ejemplo el peso W21 está ubicado entre la primera entrada (x1) y la neurona 2.


Codigo:

//Perceptrón multicapa: Puerta Lógica XOR
package perceptronMultiCapa;

import java.util.Scanner;

public class RNeuronaXor {

    public static void main(String[] args) {
        //Introducción manual de las entradas x1, x2.
        System.out.println("Introduce Entrada X1 (1,-1)): ");
        Scanner leerX1 = new Scanner(System.in);
        double x1 = Double.parseDouble(leerX1.next());
        System.out.println("Introduce Entrada X2 (1,-1): ");
        Scanner leerX2 = new Scanner(System.in);
        double x2 = Double.parseDouble(leerX2.next());
        //Pesos ya calibrados para la resolución de puertas XOR.
        double w11 = -1.942779536696304;//Pesos neurona 1
        double w12 = -2.4033439922084954;
        double θ1 = -2.2690966258542424;
        double w21 = 1.476484576128277;//Pesos neurona 2

        double w22 = 1.5285706752204653;
        double θ2 = -1.2654579142409594;
        double w31 = -2.7857541174718032;//Pesos neurona 3
        double w32 = -2.81730152144229;
        double θ3 = -2.52832962325685;
        //Calculo de las salidas de las neuronas
        double y1 = Math.tanh((x1 * w11) + (x2 * w12) + (1 * θ1));
        double y2 = Math.tanh((x1 * w21) + (x2 * w22) + (1 * θ2));
        double y3 = Math.tanh((y1 * w31) + (y2 * w32) + (1 * θ3));
        y3 = (y3 >= 0) ? 1 : -1;
        //Mostrar resultado
        System.out.println("Salida (y3) = " + (int) y3);
    }

}



Resultado:

run:
Introduce Entrada X1 (1,-1)):
-1
Introduce Entrada X2 (1,-1):
1
Salida (y3) = 1
BUILD SUCCESSFUL (total time: 4 seconds)


sábado, 15 de febrero de 2014

Operaciones matemáticas. Multiplicación de un vector por una matriz.












Codigo:

package vectorpormatriz;

public class VectorPorMatriz {

    public static void main(String[] args) {

        int[] x = new int[3];
        int[][] w = new int[3][4];
        int[] h = new int[w[0].length];

        String aux = "";

        //LLenar con valores aleatorios w, h, x.
        for (int i = 0; i < w.length; i++) {
            x[i] = (int) Math.floor(Math.random() * 89) + 10;
            for (int j = 0; j < w[0].length; j++) {
                w[i][j] = (int) Math.floor(Math.random() * 89) + 10;
            }
        }

        //Multiplica x por w       
        for (int i = 0; i < w[0].length; i++) {
            int sum = 0;
            for (int j = 0; j < x.length; j++) {
                sum += x[j] * w[j][i];
            }
            h[i] = sum;
        }


        //Mostrar vector
        System.out.println("* Vector:");
        for (int i = 0; i < x.length; i++) {
            aux += "  " + x[i];
        }
        System.out.println(aux);

        //Mostrar matriz
        System.out.println("\n* Matriz:");
        for (int[] m1 : w) {
            aux = "";
            for (int j = 0; j < w[0].length; j++) {
                aux += "  " + m1[j];
            }
            System.out.println(aux);
        }

        //Mostrar resultado
        aux = "";
        System.out.println("\n* Vector x Matriz:");
        for (int i = 0; i < h.length; i++) {
            aux += "  " + h[i];
        }
        System.out.println(aux);
    }

}



Resultado:

run:
* Vector:
  70  62  39

* Matriz:
  34  66  31  59
  84  75  27  34
  25  54  57  35

* Vector x Matriz:
  8563  11376  6067  7603
BUILD SUCCESSFUL (total time: 0 seconds)



martes, 11 de febrero de 2014

Operaciones matemáticas. Sumatorio.














Codigo:

//Sumatorio
package sumatorio;
import java.util.Scanner;
public class Sumatorio {
    public static void main(String[] args) {
        //Inicializar variables
        int[] x = new int[5];
        for (int i = 1; i < x.length; i++) {
            System.out.println("Introduce valor X" + i + ":");
            Scanner leer = new Scanner(System.in);
            x[i] = Integer.parseInt(leer.next());
        }
        int n = x.length;
        int m = 1;
        int sumatorio = 0;
        String formula = "";
        //Sumatorio
        for (int i = m; i < n; i++) {               
            sumatorio += x[i];
            formula += " + " + x[i];
        }

        System.out.println("\n∑ =" + formula.substring(2) + " = " + sumatorio);
    }
}



Resultado:

run:
Introduce valor X1:
23
Introduce valor X2:
61
Introduce valor X3:
7
Introduce valor X4:
99

∑ = 23 + 61 + 7 + 99 = 190
BUILD SUCCESSFUL (total time: 11 seconds)


lunes, 10 de febrero de 2014

Neurona artificial (IV). Perceptrón Multicapa.

A diferencia del Perceptrón Simple, el Perceptrón Multicapa esta formada por múltiples capas de neuronas. Eliminando la principal limitación del Perceptrón Simple de que no puede resolver problemas que no son linealmente separables como por ejemplo las puertas lógicas XOR.
























Codigo:

//Perceptron multicapa
package perceptronMultiCapa;

import java.util.Random;
import java.util.Scanner;

public class PerceptronMultiCapa {

    public static void main(String[] args) {
        //Introduccion manual de las entradas x1, x2.
        System.out.println("Introduce Entrada 1 (X1): ");
        Scanner leerX1 = new Scanner(System.in);
        double x1 = Double.parseDouble(leerX1.next());
        System.out.println("Introduce Entrada 2 (X2): ");
        Scanner leerX2 = new Scanner(System.in);
        double x2 = Double.parseDouble(leerX2.next());
        //Inicializar pesos con valores aleatorios.
        double w1 = new Random().nextDouble();
        double w2 = new Random().nextDouble();
        double w3 = new Random().nextDouble();
        double w4 = new Random().nextDouble();
        double w5 = new Random().nextDouble();
        double w6 = new Random().nextDouble();
        //Pesos de la constante θ (ayuda en la precisión).
        double θ1 = new Random().nextDouble();
        double θ2 = new Random().nextDouble();
        double θ3 = new Random().nextDouble();
        //Salidas primera capa y ultima (y3)
        double y1 = Math.tanh((x1 * w1) + (x2 * w3) - θ1);
        double y2 = Math.tanh((x1 * w2) + (x2 * w4) - θ2);
        double y3 = Math.tanh((y1 * w5) + (y2 * w6) - θ3);
        //Mostrar resultados
        System.out.println("Salida (y3) = " + y3);
    }
   
}



Resultado:

run:
Introduce Entrada 1 (X1):
-2.3
Introduce Entrada 2 (X2):
1.9
Salida (y3) = -0.5309976823624457
BUILD SUCCESSFUL (total time: 20 seconds)




viernes, 7 de febrero de 2014

Neurona artificial (III). Aprendizaje (puerta lógica AND)

Esta vez y siguiendo el ejemplo anterior, lo mismo pero con puerta lógica AND. Solo hace falta substituir los valores de la  tabla de verdad del anterior ejemplo por las de la siguiente tabla:




























Codigo:

//Aprendizaje puerta logica AND
package neurona4;

import java.util.Random;
import java.util.Scanner;

public class Neurona4 {

    public static void main(String[] args) {
        //Tabla de la verdad puerta AND (X1,X2,Y1)
        int[][] tv = {{1, 1, 1}, {1, -1, -1}, {-1, 1, -1}, {-1, -1, -1}};
       
        double w1 = new Random().nextDouble();
        double w2 = new Random().nextDouble();
        double θ = -0.4;

        double y = 0;
        final double E = 0.6;//Factor de aprendizaje 

        System.out.println("Iniciando fase de aprendizaje puerta logica AND...");
        int i = 0;
        int cont = 1;
        while (i < tv.length && cont < 10000) {
            y = Math.tanh((tv[i][0] * w1) + (tv[i][1] * w2) + (-1 * θ));
            y = (y >= θ) ? 1 : -1;           
            if (y == tv[i][2]) {
                i++;
            } else {
                //Ajuste de pesos
                w1 = w1 + 2 * E * tv[i][2] * tv[i][0];
                w2 = w2 + 2 * E * tv[i][2] * tv[i][1];
                θ = θ + 2 * E * tv[i][2] * (-1);
                cont++;
                i = 0;
            }
        }

        if (cont <= 9999) {
            System.out.println("Fase de aprendizaje terminado con exito ");
           
            System.out.println("\nIntroduce Entrada 1 (X1): ");
            Scanner leerX1 = new Scanner(System.in);
            double x1 = Double.parseDouble(leerX1.next());

            System.out.println("Introduce Entrada 2 (X2): ");
            Scanner leerX2 = new Scanner(System.in);
            double x2 = Double.parseDouble(leerX2.next());

            y = Math.tanh((x1 * w1) + (x2 * w2) + (-1 * θ));
            y = (y >= θ) ? 1 : -1;

            System.out.println("\nSalida: " + y);
        } else {
            System.out.println("\nFase de aprendizaje ha fallado\n");
        }

    }
}


Resultado:

run:
Iniciando fase de aprendizaje puerta logica AND...
Fase de aprendizaje terminado con exito

Introduce Entrada 1 (X1):
-1
Introduce Entrada 2 (X2):
1

Salida: -1.0
BUILD SUCCESSFUL (total time: 2 seconds)



Neurona Artificial (II). Aprendizaje (puerta lógica OR).

Voy a crear un algoritmo de aprendizaje (en este caso una puerta logica OR). Para ello voy a utilizar un tipo de neurona artificial llamada perceptrón con 2 entradas.


 























Hay que tener encuenta que en este ejemplo, la salida (Y1) solo admite los valores 1 y -1, siguiendo la siguiente regla:

 1 si f(wx) >= θ
-1 si f(wx) <  θ


Para el aprendizaje de la puerta logica OR nos hará falta crear una "tabla de la verdad" del mismo:


























 



En este nuevo ejemplo de neurona aparecen 2 nuevos valores a tener encuenta:

E = Factor de aprendizaje
θ = Umbral


Y una nueva formula que servirá para ajuste de pesos:

W = W + 2E * T * X


Codigo:

//Aprendizaje puerta logica OR. (Muestra datos paso a paso)
package neuronaOR;

import java.util.Random;
import java.util.Scanner;

public class NeuronaOR {

    public static void main(String[] args) {
        //Tabla de la verdad (X1,X2,Y1)
        int[][] tv = {{1, 1, 1}, {1, -1, 1}, {-1, 1, 1}, {-1, -1, -1}};

        System.out.println("\nInicializar pesos:\n");
        double w1 = new Random().nextDouble() / 2.5;//valores proximos a 0
        double w2 = new Random().nextDouble() / 2.5;
        double θ = -0.4;

        double y = 0;
        final double E = 0.6;//Factor de aprendizaje       

        System.out.println("w1: " + w1);
        System.out.println("w2: " + w2);
        System.out.println("θ: " + θ);

        System.out.println("\nIniciando fase de aprendizaje puerta logica OR...\n");
        int i = 0;
        int cont = 1;
        while (i < tv.length && cont < 100) {
            y = Math.tanh((tv[i][0] * w1) + (tv[i][1] * w2) + (-1 * θ));
            y = (y >= θ) ? 1 : -1;
            System.out.println("Entrada[" + tv[i][0] + "," + tv[i][1]
                    + "]) Valor esperado[" + tv[i][2]
                    + "] Salida[" + (int) y + "]");
            if (y == tv[i][2]) {
                i++;
            } else {
                System.out.println("Valor esperado difiere de la salida. Hay que reajustar pesos...");
                //Ajuste de pesos
                w1 = w1 + 2 * E * tv[i][2] * tv[i][0];
                w2 = w2 + 2 * E * tv[i][2] * tv[i][1];
                θ = θ + 2 * E * tv[i][2] * (-1);

                System.out.println("\nAjuste de pesos (" + cont + "):");
                System.out.println("w1: " + w1);
                System.out.println("w2: " + w2);
                System.out.println("θ: " + θ + "\n");
                cont++;
                i = 0;
            }
        }

        if (cont <= 9999) {
            System.out.println("\nFase de aprendizaje terminado con exito ");
            System.out.println("\nResultados:");
            System.out.println("w1: " + w1);
            System.out.println("w2: " + w2);
            System.out.println("θ: " + θ);
            System.out.println("\nIniciando fase de testeo...");
            System.out.println("Introduce Entrada 1 (X1): ");
            Scanner leerX1 = new Scanner(System.in);
            double x1 = Double.parseDouble(leerX1.next());

            System.out.println("Introduce Entrada 2 (X2): ");
            Scanner leerX2 = new Scanner(System.in);
            double x2 = Double.parseDouble(leerX2.next());

            y = Math.tanh((x1 * w1) + (x2 * w2) + (-1 * θ));
            y = (y >= θ) ? 1 : -1;

            System.out.println("\nSalida: " + (int)y);
        } else {
            System.out.println("\nFase de aprendizaje ha fallado\n");
        }

    }
}


Resultado:

run:

Inicializar pesos:

w1: 0.3223614553902566
w2: 0.11581465997718018
θ: -0.4

Iniciando fase de aprendizaje puerta logica OR...

Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[1]
Entrada[-1,-1]) Valor esperado[-1] Salida[1]
Valor esperado difiere de la salida. Hay que reajustar pesos...

Ajuste de pesos (1):
w1: 1.5223614553902567
w2: 1.31581465997718
θ: 0.7999999999999999

Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[-1]
Valor esperado difiere de la salida. Hay que reajustar pesos...

Ajuste de pesos (2):
w1: 2.7223614553902564
w2: 0.1158146599771801
θ: -0.4

Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[-1]
Valor esperado difiere de la salida. Hay que reajustar pesos...

Ajuste de pesos (3):
w1: 1.5223614553902565
w2: 1.31581465997718
θ: -1.6

Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[1]
Entrada[-1,-1]) Valor esperado[-1] Salida[1]
Valor esperado difiere de la salida. Hay que reajustar pesos...

Ajuste de pesos (4):
w1: 2.7223614553902564
w2: 2.5158146599771802
θ: -0.40000000000000013

Entrada[1,1]) Valor esperado[1] Salida[1]
Entrada[1,-1]) Valor esperado[1] Salida[1]
Entrada[-1,1]) Valor esperado[1] Salida[1]
Entrada[-1,-1]) Valor esperado[-1] Salida[-1]

Fase de aprendizaje terminado con exito

Resultados:
w1: 2.7223614553902564
w2: 2.5158146599771802
θ: -0.40000000000000013

Iniciando fase de testeo...
Introduce Entrada 1 (X1):
1
Introduce Entrada 2 (X2):
-1

Salida: 1

BUILD SUCCESSFUL (total time: 3 minutes 25 seconds)


lunes, 3 de febrero de 2014

Neurona Artificial (I). Perceptrón Simple.

En este apartado voy a crear una neurona artificial muy básica. Más adelante iré añadiendo nuevas caracteristicas hasta llegar a crear una red neuronal artificial funcional que  sea capaz de aprender y resolver problemas complejos.

El funcionamiento de una "neurona" artificial se puede deducir observando el siguiente esquema:




Codigo1 (Perceptron.java):

package neurona2;

import java.util.Random;

public class Perceptron {

    public static void main(String[] args) {


        //Valores Entradas
        double x1 = 1.4;
        double x2 = -0.33;


        //Valores Pesos (aleatorios)
        double w1 = new Random().nextDouble();
        double w2 = new Random().nextDouble();

        Neurona n = new Neurona(x1, x2, w1, w2);

        System.out.println("Entrada 1 (x1): " + x1);
        System.out.println("Entrada 2 (x2): " + x2);
        System.out.println("Salida 1 (y1) = " + n.getY1());
       
    }

}



Codigo 2 (Neurona.java):

package neurona2;

public class Neurona {

    final double x1, x2, w1, w2;

    Neurona(double x1, double x2, double w1, double w2) {
        this.x1 = x1;
        this.x2 = x2;
        this.w1 = w1;
        this.w2 = w2;
    }

    public double getY1() {
        double wx, y1;
        wx = (x1 * w1) + (x2 * w2); //Función propagación
        y1 = Math.tanh(wx); //Salida
        return y1;
    }
}



Resultado:

run:
Entrada 1 (x1): 1.4
Entrada 2 (x2): -0.33
Salida 1 (y1) = -0.2846455790167466
BUILD SUCCESSFUL (total time: 0 seconds)


Con la tecnología de Blogger.