TALLER # 2 ENTRENAMIENTO Y SIMULACION DE

REDE NEURALES ARTIFICIALES

PROFESOR:
TONY JIMENEZ

ALUMNOS:
JOSÉ LUIS ÁLVAREZ CAMPO

MATERIA:
INTELIGENCIA ARTIFICIAL

UNIVERSIDAD POPULAR DEL CESAR

FACULTAD DE INGENIERÍAS Y TECNOLÓGICAS
VALLEDUPAR CESAR
2020
 Vista general del taller #2, aquí muestro todas las clases y funciones que se
utilizaron para realizar acabo los ejercicios propuesto

 Esta vista muestras las clases, que serían nuestro ejercicios (1,2,3…)
Ejercicio 1.

Nota: Para que nuestra red aprenda tenemos que entrenarla primero.

En este ejercicio tenesmo un vector de 10 elementos

En la sentencia int[] capas =new int[] {10,10,1}; ----> aquí estamos declarando la topología
de la red con 10 entradas, una capa oculta con 10 neuronas y 1 salida

En la sentencia double[] [] entrada = new double[] {{2,2,2,2,10,10,2,2,2,2}}; ---> aquí

estamos declarando las entrada del vector como no establece el ejerció y su salida seria 1
(igual a T) como muestra la imagen

En esta parte vemos una rata de aprendizaje de 0.6 y también el entrenamiento de la red
con una iteración de 1000 entre mayor sea la iteración mas aprende nuestra red
Aquí se prueba la red con todo el parámetro y configuraciones ya establecido

Ejercicio 2.

Nota: La sentencia java.util.Random es una librería de java que sirve para generar números
aleatorios la utilizamos para este ejercicio para que nuestra red vaya haciendo cálculos con
numero aleatorios.
En el ejercicios 2 nos establecen un red con aprendizaje backpropagation con una funcion
F(x,y,z) = sen(x)+ cos(y)+z
En la sentencia int[] capas =new int[] {3,10,10,1}; ---> Establecemos la topología de la red
con 3 entradas, 2 capas ocultas de 10 neuronas y 1s salida.
Yo establecí una entrada [10] [3] y salida [10][1], para calcular la operación sen y cos en java
encontramos una librería Math que tiene incorporado propiedades y métodos para constantes
y funciones matemáticas en este caso utilizaremos Math.sin que devuelve el seno de un
número y Math.cos que devuelve el coseno de un número.

Esta es la parte de entrenamiento y aprendizaje de esta red, establecí una rata de

aprendizaje de 0.6 y numero de iteraciones de 1000 para algunos de los ejercicios.
Ya aquí nos muestra como entreno y aprendió nuestra red, en general lo que hago en este
código es entrenar la red con valores aleatorios (x, y, z) y hacer sus receptiva operaciones
(en esta caso la funcion).

Ejercicio 3
En este ejercicio vamos a simular una compuerta AND, se dice que una compuerta and
cuando sus entradas son ambas verdaderas su salida es verdadera, en este caso entramos
una red para que nos simule esta compuerta como dice ejercicio

 int[] capas =new int[] {2,2,1}; ----> aquí estamos declarando la topología de la red
con 2 entradas, una capa oculta de 2 neuronas y 1 salida.
 double[][] entradas = new double[][] { { 1, 1 }, { 1, 0 }, { 0, 0 }, { 0, 1 } }; ----> aquí
estamos declarando la entrada de la red.
 double[][] salidas = new double[][] { { 1 }, { 0 }, { 0 }, { 0 } }; ----> aquí declaramos la
salida de red.
 PérceptronMulticapa pm = new PérceptronMulticapa(capas, 0.1, new
TransferenciaHiperbólica()); ----> aquí declaramos la rata de Aprendizaje.
 for (int k = 0; k < 1000; k++) aquí declaramos el número de iteraciones que es 1000.
 double[] _entradas = { 1, 0 }; ----> aquí declaramos la entrada que queremos que
nuestra red entrene y aprenda, ejemplo en la siguiente imagen:
Nota: y así sucesivamente vamos con las demás compuertas OR y XOR su estructura es lo
mismo, solo que cambia su resultado en la compuerta OR cuando sus entradas son falsa su
salida es falsa(0) y en la XOR si sus entrada no son iguales su salida es verdaderas.

OR
XOR

 int[] capas = new int[] { 2, 2, 1 }; -----> aquí declaramos la topoligia de la red, con 2
entradas, una capa oculta de 2 neurona y 1 salida.
 double[][] entradas = new double[][] { { 1, 1 }, { 1, 0 }, { 0, 0 }, { 0, 1 } }; -----> aquí
declaramos la entrada de la red.
 double[][] salidas = new double[][] { { 0 }, { 1 }, { 0 }, { 1 } }; -----> aquí declaramos
la salida de la red.
 PérceptronMulticapa pm = new PérceptronMulticapa(capas, 0.1, new
TransferenciaHiperbólica()); -----> aquí de inicializa la perceptron, con una rata de
aprendizaje 0.1
//prueba
 double[][] __entradas = new double[][] { { 1, 1 }, { 1, 0 }, { 0, 0 }, { 0, 1 } }; ---> aquí
esta haciendo prueba en todos los patrones de entrada
 Aquí mostramos el entrenamiento y el aprendizaje de nuestra red, con su respectivo
resultado.

Ejercicio 4.
  int[] capas = new int[] { 2, 3, 2 }; ----> aquí estamos declarando la topología de la
red con 2 entradas, una capa oculta de 3 neuronas y 2 salida.
 double[][] entradas = new double[][] { { -1, -1 }, { -1, 1 }, { 1, -1 }, { 1, 1 } }; ----> aquí
declaramos la entrada de la red.
 double[][] salidas = new double[][] { { -1, -1 }, { 1, -1 }, { 1, -1 }, { -1, 1 } }; ----> aquí
declaramos la salida de la red.
 PérceptronMulticapa pm = new PérceptronMulticapa(capas, 0.6, new
TransferenciaHiperbólica()); ----> aquí declaramos una rata de Aprendizaje que es
de 0.6
 for (int k = 0; k < 50000; k++) ----> aquí declaramos el número de iteraciones que es
50000.

Aquí mostramos el entrenamiento y el aprendizaje de nuestra red, con su respectivo

resultado.
Ejercicio 5.

 int[] capas = new int[] { 3, 3, 2 }; ----> aquí estamos declarando la topología de la

red con 3 entradas, una capa oculta de 3 neuronas y 2 salida.
 double[][] entradas = new double[][] { { 1, 1, 1 }, { -1, 1, 1 }, { 1, 1, -1 }, { -1, -1, -1 }
}; }; ----> aquí declaramos la entrada de la red.
 double[][] salidas = new double[][] { { -1, -1 }, { -1, 1 }, { 1, -1 }, { 1, 1 } }; }; ----> aquí
declaramos la salida de la red.
 PérceptronMulticapa pm = new PérceptronMulticapa(capas, 0.6, new
TransferenciaHiperbólica()); ----> aquí declaramos una rata de Aprendizaje que es
de 0.6
 for (int k = 0; k < 1000; k++) ----> aquí declaramos el número de iteraciones que es
1000.
Aquí mostramos el entrenamiento y el aprendizaje de nuestra red, con su respectivo
resultado.
Nota: la sentencia Math.round sirve para retorna el valor de un número redondeado al
entero más cercano.

Ejercicio 6.

 int[] capas = new int[] { 3, 4, 4, 2 }; ----> aquí estamos declarando la topología de la

red con 3 entradas, dos capa oculta de 4 neuronas y 2 salida.
  double[][] entradas = new double[][] { { 0.1, 0.9, 0.1 }, { 0.1, 0.1, 0.9 }, { 0.1, 0.1, 0.1
}, { 0.9, 0.9, 0.9 } }; ----> aquí declaramos la entrada de la red.
 double[][] salidas = new double[][] { { 0.1, 0.9 }, { 0.1, 0.9 }, { 0.1, 0.1 }, { 0.9, 0.9 }
}; ----> aquí declaramos la salida de la red.
 PérceptronMulticapa pm = new PérceptronMulticapa(capas, 0.6, new
TransferenciaHiperbólica());----> aquí declaramos una rata de Aprendizaje que es
de 0.6
 for (int k = 0; k < 1000; k++) ----> aquí declaramos el número de iteraciones que es
1000.

Aquí mostramos el entrenamiento y el aprendizaje de nuestra red, con su respectivo

resultado.
Ejercicio 7.
 int[] capas = new int[] { 35, 10, 10, 28 }; -----> Aquí declaramos la topología de la
red, con 35 entradas, dos capa ocultas de 10 neuronas y 28 salidas.
 double[][] entradas = new double[][] -----> aquí declaramos las entradas de la red,
ya que es una matriz de 7x5, en esta matriz vamos a representar las letras del
abecedario (A,B,C,D,E… y asi sucesivamente.)
 double[][] salidas = new double[][] -----> aquí declaramos las salidas de la red, según
sea la configuración de la red y sus entradas, la salida rogará un resultada según lo
deseado.
 PérceptronMulticapa pm = new PérceptronMulticapa(capas, 0.6, new
TransferenciaSigmoidal()); -----> aquí inicializamos la percentron con una rata de
aprendizaje 0.6
  for (int k = 0; k < 50000; k++) -----> aquí declaramos el número de iteraciones que es
50000.
// prueba
 double[][] __entradas = new double[] -----> aquí está haciendo prueba en todos los
patrones de entrada que se le desee ingresar.

Aquí como vemos en la imagen ya nuestra red entrenó y aprendió, en la entrada de pruebas
encontramos el patrón de la letra E y en su salida no muestra su patrón asociado a esa letra,
y así sucesivamente con las demás letras del abecedario.

Aquí simulamos la letra T , con su patrón asociado ala salida

 Aquí mostramos Cuando el patrón de entrada es equivalente a 1 y su respectivo patrón de
salida asociado.

Aquí mostramos Cuando el patrón de entrada es equivalente a 0 y su respectivo patrón de

salida asociado.
La interfaz de la FunciónDeTransferencia , TransferenciaHiperbólica,
TransferenciaSigmoidal están funciones se asocian a las capas , cada capa tiene su funcion
de transferencia, sirven para activar la neurona y una vez que se activa la neurona se verifica
con el umbral.
Clase capa, una capa tiene neurona y tiene logitud aque se estamos defiendo.

En clase Neurona, definimos un valor, un peso, un umbral, un delta

public Neurona(int largoCapaAnterior) -----> construtor de la neurona cuando se crea la
neurona la primera vez está generara valores aleatorios porque así está establecido.
Para resumir el código en la clase percentronmulticapa es la clase mas, en nuestra red
neuronal . es la que hace todo, la que inicializa, se le manda un rataio de aprendizaje, con
sus respectiva funciones en ellas definimos:
double RatioDeAprendizaje = 0.6;
FunciónDeTransferencia FunciónDeTransferencia;
encontramos un método guardar y cargar como su nombre nos indica el método guardar
guarda el estado de la red (pesos,umbrales), y el método cargar los carga.
También encontramos un método ejecutar, consiste en tomas las entradas y las mandas
hacia delante