Por: Luis Roberto Feijoo Jara

DESRIPCIÓN DEL ALGORITMO UTILIZADO EN LA APLICACIÓN

El algoritmo Backpropagation se resume en los siguientes pasos:

Inicializar los pesos de forma aleatoria y con valores pequeños. En la

imagen de abajo podemos ver como se inicializan los pesos sumando a

0,01 un valor aleatorio bajo. Aquí se esta inicializando los pesos para

todas las neuronas de la red.

Calculamos la salida de la red

Como vemos en la imagen de abajo, primeramente aplicamos entradas

a la red y calculamos salidas más altas.

Calculamos la capa de salida y primeros errores para cada salida.

Ajustamos los pesos de la red de forma que se minimice el error

A continuación muestro como se actualiza la primera capa de pesos:

Esto obedece a la siguiente formula Dwij=-h E/ wij

Donde –n es la taza de aprendizaje. En nuestro caso LearningRate es nuestra

taza de aprendizaje, multiplicando para la salida deseada, y para el valor del

peso entrante de dicha neurona. Esto se hace con todas las neuronas con la

finalidad de minimizr el error.

Se repiten los pasos anteriores

Fase hacia delante:

o Calcular la salida de la red para cada patrón de entrada.

o Calcular el error total cometido (SSE)

o Si la condición de terminación se satisface, parar

En la imagen de abajo primeramente se aplica las entradas a la

red, se hace un calculo de las salidas, y de los errores en la capa

que se esta trabajando.

Calcula el error en la salida para cada patrón

Como se calcula la Taza de Error:

ep2: Error medio cuadrático para cada patrón de salida

= Error en cada neurona de la capa de salida

En la aplicación podemos ver que se está calculando el error medio

cuadrático para cada salida.

En conclusión el agoritmo backpropagatión sigue esta estructutra:

Como es la fase de entrenamiento de la red

Primeramento se hace la propagación hacia adelante en el que se calculan las salidas

y errores , a continuación se hace un recalculo de pesos con la finalidad de minimizar

el error, y por ultimo se obtiene el error actual. Es importante aclarar que esto se hace

hasta satisfacer una condición que es de que el error maximo no debe ser mayor al

error actual, esto nos da el numero de iteraciones de la fase de entrenamiento.

Selección de los conjuntos de entrenamiento y prueba

El archivo contiene un conjunto de 36 elementos entre los cuales tenemos letras (A hasta la Z) y números (0 hasta 9)

Estos ejemplos se dividieron en dos conjuntos mutuamente excluyentes: un conjunto de aprendizaje y otro conjunto de prueba.

En diferentes pruebas, se hizo variar el tamaño del conjunto de aprendizaje entre un 83% y un 99% del total de ejemplos disponibles, dejando los ejemplos restantes para el conjunto de prueba.

Se entrenaba a la red con el conjunto de aprendizaje y se realizaban pruebas con los ejemplos restantes.

Luego de diversas pruebas con distintas configuraciones de la red y tamaños de conjuntos de aprendizaje, se notó que existían ciertos patrones del conjunto de prueba que eran clasificados erróneamente por la red en forma recurrente (Caso de la letra B y Q).

En algunos casos como la A, he elegido patrones de distintos tipo me refiero a distintos tipos con distintas formas de representar esta letra. Así también con otras letras, con esto se podrá probar que tan eficiente es la red al momento de reconocer diferentes patrones que representen una sola letra. A continuación muestro una imagen de los distintos tipos de A que pueden reconocer la aplicación:

Como se convierte la imagen a matriz:

Para convertir la imagen a matriz se debe hacer cálculos, dividiendo su alto de la

imagen para 27 ya que serán 27 filas de la matriz y esto nos dará un valor aproximado

del valor de cada fila, así mismo con las columnas, se divide el valor del ancho de la

imagen para 24 ya que tendremos 24 columnas y esto nos dará un valor aproximado

del ancho de cada columna. Con esto ya tenemos el valor aproximado de cada

espacio de la matriz con esto podemos proceder a realizar la comparación de los

patrones analizando celda a celda de la matriz, obteniendo los pixeles para saber si se

encuentra pintado de negro y así realizar la comparación mediante el algoritmo

backpropagation. Esto podemos ver a continuación:

A continuación pongo todo el algoritmo backpropagation utilizado en la aplicación:

// ********* APLICACION DEL ALGORITMO BACKPROPAGATION: ****************** #region IBackPropagation<T> Members public void Backpropagation() { //Actualizar la primera capa de pesos -> Calculo la capa de entrada de los pesos for (int j = 0; j < OutputNum; j++) { for (int i = 0; i < PreEntradaNum; i++) { PreEntradaLayer[i].Pesos[j] += LearningRate * (OutputLayer[j].Error) * PreEntradaLayer[i].Value; } } } public double F(double x) { return (1 / (1 + Math.Exp(-x))); } //Propagacion hacia Adelante public void PropagacionAdelante(double[] pattern, T output) { int i, j; double total = 0.0; //Aplicar la entrada a la red for (i = 0; i < PreEntradaNum; i++) { PreEntradaLayer[i].Value = pattern[i]; } //Calcular la primera salida, capas de entrada, salidas y errores for (i = 0; i < OutputNum; i++) { total = 0.0; for (j = 0; j < PreEntradaNum; j++) { total += PreEntradaLayer[j].Value * PreEntradaLayer[j].Pesos[i]; } OutputLayer[i].Suma = total; OutputLayer[i].output = F(total); OutputLayer[i].Target = OutputLayer[i].Value.CompareTo(output) == 0 ? 1.0 : 0.0; OutputLayer[i].Error = (OutputLayer[i].Target - OutputLayer[i].output) * (OutputLayer[i].output) * (1 - OutputLayer[i].output); } } //Calcula el error cuadratico medio public double ObtenerError() { double total = 0.0; for (int j = 0; j < OutputNum; j++) { total += Math.Pow((OutputLayer[j].Target - OutputLayer[j].output), 2) / 2;

} return total; } //Inicializa Red public void InicializarRed(Dictionary<T, double[]> Entrenamiento) { Random rand = new Random(); for (int i = 0; i < PreEntradaNum; i++) { PreEntradaLayer[i].Pesos = new double[OutputNum]; for (int j = 0; j < OutputNum; j++) { PreEntradaLayer[i].Pesos[j] = 0.01 + ((double)rand.Next(0, 2) / 100); } } int k = 0; foreach (KeyValuePair<T, double[]> p in Entrenamiento) { OutputLayer[k++].Value = p.Key; } } // ******************** FASE DE RECONOCIMIENTO DE CARACTERES ******************** public void Reconocer(double[] Entrada, ref T UnirAlto, ref double OutputValueHight, ref T UnirBajo, ref double OutputValueLow) { int i, j; double total = 0.0; double max = -1; //Aplicar entrada a la red for (i = 0; i < PreEntradaNum; i++) { PreEntradaLayer[i].Value = Entrada[i]; } //Encontrar las salidas mas altas for (i = 0; i < OutputNum; i++) { total = 0.0; for (j = 0; j < PreEntradaNum; j++) { total += PreEntradaLayer[j].Value * PreEntradaLayer[j].Pesos[i]; } OutputLayer[i].Suma = total; OutputLayer[i].output = F(total); if (OutputLayer[i].output > max) { UnirBajo = UnirAlto; OutputValueLow = max; max = OutputLayer[i].output; UnirAlto = OutputLayer[i].Value; OutputValueHight = max; } } }

#endregion //FIN DEL ALGORITMO BACKPROPAGATION public double LearningRate { get { return learningRate; } set { learningRate = value; } } }