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

Tangente Hiperbólica

Gaussiana

Sigmoide

Tangente Hiperbólica

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