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)
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)
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)
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)
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)
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)
Usando Netbeans 7.4 creamos un nuevo proyecto con un JFrame Form.
En modo de diseño le agregamos el componente "Progress Bar" y un "Button".
Deberia quedar algo asi:
Codigo Principal:
package barraprogreso1;
public class BarraProgreso1 extends javax.swing.JFrame {
public BarraProgreso1() {
initComponents();
jProgressBar1.setMaximum(100);
}
@SuppressWarnings("unchecked")
private void initComponents() { ... }
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt){
Worker worker = new Worker (jProgressBar1);
worker.execute();
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new BarraProgreso1().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JProgressBar jProgressBar1;
// End of variables declaration
}
Codigo Clase Worker:
package barraprogreso1;
import java.util.List;
import javax.swing.JProgressBar;
import javax.swing.SwingWorker;
public class Worker extends SwingWorker {
private final JProgressBar progreso;
Worker(JProgressBar barra) {
progreso = barra;
}
@Override
public Double doInBackground() throws Exception {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
}
publish(i + 1);
}
return 100.00;
}
@Override
protected void done() {
System.out.println("Proceso a acabado");
}
@Override
protected void process(List chunks) {
//Actualizando la barra de progreso. Datos del publish.
progreso.setValue(chunks.get(0));
}
}
Resultado:
