Algoritmos en redes neuronales

Perceptrón multicapa

Conocer el problema

 Entradas
 Salidas
 Patrones

Tipos de datos (E/S)

 Binario
 Bipolar
 Real

Algoritmos de entrenamientos

 Regla Delta
 Regla Delta Modificada
Función de Activación (afectan la salida)

Esta función de activación debe ser la misma para cada capa, pero a la vez
cada capa independiente de la otra puede utilizar una distinta, es decir que si la
capa 1 utiliza la función sigmoide, la capa 2 puede utilizar Gaussiana.

Capas Ocultas Capa de Salida

 Sigmoide  Sigmoide
 Tangente Hiperbólica  Tangente Hiperbólica
 Gaussiana  Gaussiana
 Lineal

Inicialización de pesos y umbrales

Estos se hacen aleatoriamente al iniciar por primera vez nuestro entrenamiento

en caso de que nuestro problema no los tenga. Por lo general estos pesos y
umbrales están dentro del rango de -1 y 1.

Parámetros de entrenamientos

 Numero de iteraciones: indica la cantidad de iteraciones que hará

internamente la red.

 Error máximo permitido: es el parámetro hasta con que error vamos a

entrenar la red neuronal. Es el maestro.

 Rata de aprendizaje (α): es la que le da la velocidad al entrenamiento y

por lo general está dentro del rango de cero y uno (0 y 1).

Si utilizamos el algoritmo de entrenamiento Regla Delta Modificada la rata de

aprendizaje debe ser Dinámica.
Entrenamiento de una red Perceptrón multicapa

Funciones de activación (𝝏)

Sigmoide

1
𝑓 𝑥 =
1 + 𝑒 −𝑥
𝑒 −𝑥
𝑓′ 𝑥 =
1 + 𝑒 −𝑥 2

Tangente Hiperbólica

1 − 𝑒 −𝑥
𝑓 𝑥 =
1 + 𝑒 −𝑥

′
𝑒 −𝑥 1 − 𝑒 −𝑥 𝑒 −𝑥
𝑓 𝑥 = +
1 + 𝑒 −𝑥 1 + 𝑒 −𝑥 2
Lineal

𝑓 𝑥 =𝑥

𝑓′ 𝑥 = 1

Gaussiana
2
𝑓 𝑥 = 𝑒 −𝑥
2
𝑓′ 𝑥 = −2𝑥 ∗ 𝑒 −𝑥
Salidas de las neuronas de la primera capa oculta

ℎ1𝑖 = 𝜕 𝑥𝑗 ∗ 𝐼𝑤𝑗𝑖 − 𝑢1𝑖

𝑗 =1
𝑖=1…𝑛

Salidas de las neuronas de la segunda capa oculta

𝑛

ℎ2𝑙 = 𝜕 ℎ1𝑖 ∗ 𝐿𝑤𝑖𝐿 − 𝑢2𝑖

𝑖=1 𝐿=1…𝑛𝑛

Salida de la red neuronal

𝑛𝑛

𝑌𝑅𝑘 = 𝜕 ℎ2𝐿 ∗ 𝐿𝑤𝑤𝐿𝑘 − 𝑢3𝑘

𝐿=1 𝑘=1…𝑛𝑛𝑛

Errores Lineales producidos a la Salida de la red neuronal

𝐸𝑙𝑘 = 𝑌𝑑𝑘 − 𝑌𝑅𝑘

Error por patrón

 Cuando hay una salida

𝐸𝑝 = 𝐸𝑙𝑘
 Cuando hay más de una salida

𝐸𝑙𝑘
𝐸𝑝 =
𝑘

Teniendo todos estos datos poder modificar los pesos y umbrales

 Para Regla Delta

Pesos

𝐼𝑤𝑗𝑖 𝑘+1 = 𝐼𝑤𝑗𝑖 𝑘 + 𝛼 ∗ 𝐸𝑝 ∗ 𝑥𝑗

𝐿𝑤𝑖𝐿 𝑘+1 = 𝐿𝑤𝑖𝐿 𝑘 + 𝛼 ∗ 𝐸𝑝 ∗ ℎ1𝑖

𝐿𝑤𝑤𝐿𝑘 𝑘+1 = 𝐿𝑤𝑤𝐿𝑘 𝑘 + 𝛼 ∗ 𝐸𝑙𝑘 ∗ ℎ2𝑘

Umbrales

𝑢1𝑖 𝑘+1 = 𝑢1 𝑘 + 𝛼 ∗ 𝐸𝑝

𝑢2𝐿 𝑘+1 = 𝑢2 𝑘 + 𝛼 ∗ 𝐸𝑝

𝑢3𝑘 𝑘+1 = 𝑢3 𝑘 + 𝛼 ∗ 𝐸𝑙𝑘

 Para Regla Delta Modificada

Pesos

𝐼𝑤𝑗𝑖 𝑘+1 = 𝐼𝑤𝑗𝑖 𝑘 + 𝛼 ∗ 𝐸𝑝 ∗ 𝑥𝑗 + &(𝐼𝑤𝑗𝑖 𝑘 − 𝐼𝑤𝑗𝑖 𝑘−1 )

𝐿𝑤𝑖𝐿 𝑘+1 = 𝐿𝑤𝑖𝐿 𝑘 + 𝛼 ∗ 𝐸𝑝 ∗ ℎ1𝑖 + &(𝐿𝑤𝑖𝐿 𝑘 − 𝐿𝑤𝑖𝐿 𝑘−1 )

𝐿𝑤𝑤𝐿𝑘 𝑘+1 = 𝐿𝑤𝑤𝐿𝑘 𝑘 + 𝛼 ∗ 𝐸𝑙𝑘 ∗ ℎ2𝑘 + &(𝐿𝑤𝑤𝐿𝑘 𝑘 − 𝐿𝑤𝑤𝐿𝑘 𝑘−1 )

Umbrales

𝑢1𝑖 𝑘+1 = 𝑢1 𝑘 + 𝛼 ∗ 𝐸𝑝 + &(𝑢1𝑖 𝑘 − 𝑢1𝑖 𝑘−1 )

𝑢2𝐿 𝑘+1 = 𝑢2 𝑘 + 𝛼 ∗ 𝐸𝑝 + &(𝑢2𝐿 𝑘 − 𝑢2𝐿 𝑘−1 )

𝑢3𝑘 𝑘+1 = 𝑢3 𝑘 + 𝛼 ∗ 𝐸𝑙𝑘 + &(𝑢3𝑘 𝑘 − 𝑢3𝑘 𝑘−1 )

Hallamos el error Erms

𝐸𝑝
𝐸𝑟𝑚𝑠 =
# 𝑝𝑎𝑡𝑟𝑜𝑛𝑒𝑠
Hay que validar siempre que

𝐸𝑟𝑚𝑠 < 𝐸𝑟𝑟𝑜𝑟 max 𝑝𝑒𝑟𝑚𝑖𝑡𝑖𝑑𝑜

Como interpretar y realizar un algoritmo para resolver
una red neuronal Perceptrón multicapa

Lo que primeramente debemos tener en cuenta para resolver este tipo de

problemas, es tener claro que tenemos y que deseamos obtener. Es muy
importante analizar la estructura de la red que deseamos implementar.

Si podemos darnos cuenta nuestra red neuronal está compuesta por:

4 entradas
2 capas ocultas
1 capa de salida
la primera capa oculta contiene 9 neuronas por lo tanto contiene 9
umbrales
la segunda capa oculta contiene 5 neuronas por lo tanto contiene 5
umbrales
la capa de salida contiene 2 neuronas por lo tanto contiene 2 umbrales

Por lo general este tipo de redes presentan los datos de entradas y las salidas
correspondientes, de lo único que debemos preocuparnos en de cómo
configuramos nuestra red, de tal manera que sea mucho más eficiente.
Para el caso de los pesos y umbrales de forma inicial son aleatorios los datos.
Por eso solo debemos elegir que valores queremos que tomen al principio. Por
ejemplo como estos valores no deben salir del rango de -1 y 1.

 Para el caso de los pesos 𝐼𝑤 notamos que son en total 36 pesos que
salen de las combinaciones posibles de las entradas con la primera capa
oculta (4x9).

 Para el caso de los pesos L𝑤 notamos que son en total 45 pesos que
salen de las combinaciones posibles de la primera capa oculta con la
segunda capa oculta (9x5).

 Para el caso de L𝑤𝑤 notamos que son en total 10 pesos que salen de
las combinaciones posibles de la segunda capa oculta con la capa de
salida (5x2).

 Para el caso de 𝑢𝑛 notamos que hay tantos umbrales dependiendo de

la cantidad de neuronas que hayan en cada capa. 𝑢1 = 9 𝑢2 =
5 𝑢3 = 2

Como interpretar una ecuación matemática a un

lenguaje de programación

Es muy común que tengamos la lógica de programación en nosotros, pero hay

muchos casos que eso no es suficiente ya que cuando tenemos un sistema de
ecuación y lo deseamos llevar a un lenguaje de programación nos es imposible
hacerlo.

Para realizar este tipo de abstracción es indispensable tener una noción clara
de algunos temas de programación como: ciclos repetitivos, manejo de
vectores y matrices, manejo de funciones. No se necesita estrictamente un
lenguaje de programación específico sino que cualquiera puede funcionar, solo
basta que tengamos claro como es la sintaxis de cada lenguaje. Es por eso que
se recomienda que el programador realice sus avances en el lenguaje que
mejor domine.
Ejemplo

ℎ1𝑖 = 𝜕 𝑥𝑗 ∗ 𝐼𝑤𝑗𝑖 − 𝑢1𝑖

𝑗 =1
𝑖=1…𝑛

Si deseamos calcular las salidas de las neuronas de la primera capa oculta, la

cual se calcula con ecuación anterior. Debemos saber que significa cada uno
de sus componentes:

𝜕 ∶ Es la función de activación que hayamos escogido y como se puede notar

paro los que no lo han podido ver, esta función afecta al resultado final que se
produce dentro de los corchetes. Es decir que el valor que nos arroje la
solución del sistema de ecuación lo llevaremos a nuestra función de activación.

𝑥𝑗 ∶ Es el valor de la entrada a la red neuronal y j va tomando el valor de cada

entrada, es decir que el valor máximo de j depende de la cantidad de entradas
que haya. En nuestro caso tomara un valor máximo de cuatro.

𝑚 ∶ Toma el valor máximo de entradas a la red

𝐼𝑤𝑗𝑖 ∶ Son los valores de los pesos de la primera capa oculta con las entradas.
Los índices indican que peso hay que tomar específicamente.

𝑢1𝑖 ∶ Indica el umbral y al igual que los pesos el índice indica el umbral
específico. El primer número indica la capa a la que pertenece.

𝑖 = 1 … 𝑛 Tomara el valor máximo de neuronas por cada capa

Ahora bien la sumatoria dentro del sistema se puede representar dentro de un

ciclo repetitivo en el lenguaje de programación. Par ello el subíndice indica
donde inicia y el índice superior indica donde termina.

Pero como podemos notar fuera de los corchetes hay otro subíndice lo cual nos
indica inmediatamente que es necesario otro ciclo repetitivo que tiene como
limite el subíndice de la capa siguiente.

 Como en nuestro caso sabemos el tamaño de los pesos y umbrales

vamos a realizar los procesos ajustándolo a este sistema propuesto.

Se puede ver lo siguiente:

𝐼𝑤 𝑒𝑠 𝑑𝑒 4,9 𝐿𝑤 𝑒𝑠 𝑑𝑒 9,5 𝐿𝑤𝑤 𝑒𝑠 𝑑𝑒 5,2 𝑌𝑅 𝑒𝑠 𝑑𝑒 2

𝑢1 𝑒𝑠 𝑑𝑒 9 𝑢2 𝑒𝑠 𝑑𝑒 5 𝑢3 𝑒𝑠 𝑑𝑒 (2)

Utilizaremos el lenguaje de programación Visual Basic y lo primero que

debemos hacer es crear los vectores y matrices que componen nuestro
sistema. Recordemos que los vectores son de una dimensión mientras que las
matrices son de (nxm).

Si traemos este concepto de vectores y matrices a nuestro caso podemos ver

que los pesos corresponden a matrices mientras los umbrales son vectores.

Digamos que tenemos la siguiente tabla que representa una compuerta lógica
cualquiera

X1 X2 X3 X4 Yd1 Yd2
1 1 0 0 1 1
1 0 1 0 0 0
0 1 0 1 0 0
0 0 1 1 0 0

Declaramos primeramente nuestros vectores y matrices, esto lo hacemos de

forma global dentro del formulario para que puedan ser utilizados en cualquier
momento por el programa.

Como en Visual Basic los índices comienzan desde la posición cero entonces
debemos restar 1 a cada una de las posiciones que tenemos planteada en
nuestro sistema. Ejemplo como tenemos en la primera capa 9 neuronas al
momento de ser declaradas debemos poner 8, porque para visual basic seria
0,1,2,3,4,5,6,7,8 y en total tendría las 9 posiciones.
  Como ya conocemos los valores de la entradas y las salidas, las
inicializamos directamente dentro de nuestro formulario de arranque

No es una camisa de fuerza realizarlo de esta forma ya que la programación

tiene muchos caminos para llegar a una solución, es muy probable que hayan
muchas formas mejores de realizar este sistema.
 Como los primeros pesos y umbrales son aleatorios los generaremos
inicialmente.

 Teniendo ya las entradas, las salidas, los pesos y los umbrales ya

podemos empezar a realizar el proceso interno que se presenta dentro
de los corchetes 𝑥𝑗 ∗ 𝐼𝑤𝑗𝑖 − 𝑢1𝑖
Hemos adicionado al código anterior lo que se señala con las flechas

 Ahora aplicamos la función de activación a cada uno de los valores de

salida de cada iteración
Creamos una función que guarde en el ComboBox las funciones de activación,
el ComboBox se llama FnActivacion

Debemos iniciar esta función al formulario de arranque para que las pueda
cargar al iniciar.

Lo que hemos adicionado es lo que esta seleccionado.

Hemos adicionado para que nos muestre los pesos y umbrales iniciales,
también al final hemos declarado para que nos presente los nuevos valores
que ha tomado las primera capa h1 dependiendo de la función de activación
que hayamos elegido. Cabe recordar que no estamos validando todo ya que
solamente nos estamos enfocando en la forma de cómo se interpretan este tipo
de sistemas neuronales.

Este último bloque lo hemos introducido dentro del ciclo mayor.

Como nos hemos dado cuenta el planteamiento para resolver el sistema para
las salidas de la primera capa oculta ha funcionado. Las demás salidas se
hacen de manera análoga a esta, solo basta con tener claro que índices se
deben tomar.
Código completo
God bless