Ok - BPN

FD_ANN.
doc 20 de diciembre de 2006
DESTINO:
PROYECTOS INTELIGENTES E67

TTULO:
APLICACIN DE DESCRIPTORES DE FOURIER Y REDES NEURONALES ARTIFICIALES PARA EL RECONOCIMIENTO DE FORMAS
APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS
Pgina: 2 de 62 Fecha: 20 de diciembre de 2006
TABLA DE CONTENIDO
TABLA DE CONTENIDO.....................................................................................................2 CUADRO DE AUTORES ......................................................................................................4 CUADRO DE CONTROL......................................................................................................4 INTRODUCCIN...................................................................................................................5 LISTA DE ABREVIATURAS ...............................................................................................6 1. 1.1 1.2 1.3 1.4 1.5 2. PROCESADO DE IMAGEN ....................................................................................7 BINARIZACIN (IM2BW) ..........................................................................................8 FILTRADO (MEDFILT2).............................................................................................9 DETECCIN DEL CONTORNO (BWPERIM) .................................................................9 EXTRACCIN DEL CONTORNO ...............................................................................10 TIEMPOS DE CLCULO ...........................................................................................10 CLCULO DE LOS DESCRIPTORES DE FOURIER ......................................11 2.1 FUNCIN 1-D QUE REPRESENTE EL CONTORNO ....................................................11 2.2 DESCRIPTORES DE FOURIER ..................................................................................11 2.2.1 Invarianza a Traslaciones, rotaciones y escalado..............................................12 2.2.2 Representacin de los Descriptores de Fourier para los Objetos de nuestro Universo..............................................................................................................13 2.2.3 Tiempo de clculo...............................................................................................17 3. APLICACIN DE LA RED NEURONAL ARTIFICIAL COMO CLASIFICADOR DE FORMAS ............................................................................18 3.1 INTRODUCCIN A LAS REDES NEURONALES ARTIFICIALES..................................18 3.1.1 Definicin de Red Neuronal Artificial ................................................................18 3.1.2 Analoga Biolgica. ............................................................................................18 3.1.3 Inters de las RNA ..............................................................................................19 3.1.4 Aplicaciones de las RNA.....................................................................................20 3.1.5 Modelos de Entrenamiento-Aprendizaje ............................................................21 3.2 REDES NEURONALES BACKPROPAGATION MULTICAPA NO LINEALES.................22 3.2.1 Redes multicapa..................................................................................................22 3.2.2 Funciones de Activacin no Lineales .................................................................23 3.2.3 Algoritmo Backpropagation ...............................................................................24 3.2.4 Variaciones en el algoritmo base .......................................................................25
3.2.4.1 3.2.4.2 Mtodos Heursticos.................................................................................................................25 Tcnicas de Optimizacin Numrica........................................................................................26
3.2.5 Factores que Influyen en el Rendimiento de la Red ...........................................26 3.2.6 Problemas en el Algoritmo Backpropagation ....................................................28 3.3 IMPLEMENTACIN SOFTWARE DE LA RED NEURONAL .........................................29 3.3.1 Fases de Procesamiento y Divisin del Conjunto de Muestras..........................29 3.3.2 Creacin de la RNA ............................................................................................29 3.3.3 Entrenamiento de la RNA ...................................................................................30 3.3.4 Simulacin de la Red ..........................................................................................32
3.3.4.1 Resultados obtenidos para el algoritmo traingdx ...................................................................33
3.3.4.2 3.3.4.3 3.3.4.4 3.3.4.5 3.3.4.6 3.3.4.7
Resultados obtenidos para el algoritmo traingrp....................................................................34 Resultados obtenidos para el algoritmo traincgf ....................................................................35 Resultados obtenidos para el algoritmo traincgp ...................................................................36 Resultados obtenidos para el algoritmo traincgb ...................................................................37 Resultados obtenidos para el algoritmo trainscg....................................................................38 Resultados obtenidos para el algoritmo trainoss ....................................................................39
3.3.5 3.3.6 4.
Anlisis de los Resultados ..................................................................................40 Comparacin de Resultados con trabajos anteriores.........................................42
CONCLUSIONES Y TRABAJO FUTURO ..........................................................44
ANEXOS ................................................................................................................................45 A. B. B.1. B.2. B.3. B.4. C. C.1. C.2. C.3. C.4. LISTA DE DOCUMENTOS DE REFERENCIA .................................................45 CDIGOS EN MATLAB PARA EL PROCESADO DE LA IMAGEN Y LA EXTRACCIN DE LOS DESCRIPTORES DE FOURIER ...............................46 PROCESADO DE LA IMAGEN: BINARIZACIN, FILTRADO Y DETECCIN DEL CONTORNO (PROC_IMG.M) ....................................................................................46 PROCESADO DE LA IMAGEN: EXTRACCIN DE LAS COORDENADAS DEL CONTORNO (SACACONTORNO.M) .........................................................................47 EXTRACCIN DE LOS DESCRIPTORES DE FOURIER (SACAFDS.M) .........50 PROGRAMA PRINCIPAL (PRINCIPALFD.M) .....................................................51 CDIGOS EN MATLAB PARA LA CONSTRUCCIN, ENTRENAMIENTO Y SIMULACIN DE LA RED NEURONAL .......................................................53 CARGA DEL CONJUNTO DE DESCRIPTORES PARA ENTRENAR Y TESTEAR LA RED NEURONAL (CARGA_DATA.M) .........................................53 CONSTRUCCIN, ENTRENAMIENTO Y SIMULACIN DE LA RED (RED_TRAIN.M)......................................................................................................55 FUNCIN PARA LA INTERPRETACIN DE RESULTADOS (RESULTADOS.M) ...................................................................................................56 PROGRAMA PRINCIPAL (PRINCIPALANN.M)..................................................57
CUADRO DE AUTORES
Nombre Funcin
Ernesto Jimnez Ruiz
Desarrollo del Proyecto
CUADRO DE CONTROL
Supervisores Funcin
Gabriel Recatal Ral Marn Pedro J. Sanz
Supervisor en la construccin de la red neuronal Supervisor del procesado de imagen Coordinador de la asignatura Proyectos Inteligentes
INTRODUCCIN
Este proyecto tiene como objetivo el seleccionar una serie de descriptores que proporcionen informacin 2-D suficiente sobre un conjunto de objetos (nuestro universo de entrada), para poder realizar una clasificacin de los mismos mediante una Red Neuronal Artificial. Nuestro universo de entrada inicial ser una esfera, un cubo, una llave allen y una rueda de LEGO, presentado como un conjunto de imgenes (100 para cada objeto) en escala de grises. El inters de este sencillo universo de entrada es la posibilidad de realizar comparaciones con proyectos anteriores en los que se utiliz un conjunto de descriptores distinto [marin03]. Los descriptores que se utilizarn son los Descriptores de Fourier que nos proporcionarn informacin a cerca del contorno o frontera del objeto. Respecto a la Red Neuronal Artificial, trabajaremos con redes Backpropagation, usando diferentes topologas y algoritmos de entrenamiento. Matlab 5.3 ser la herramienta que nos permitir realizar los diferentes clculos y simulaciones, en concreto las Toolbox para Procesado de Imgenes y para la simulacin de Redes Neuronales Artificiales. El trabajo se dividir en cuatro partes: -
Procesado de imagen, realizando una binarizacin, un filtrado y un proceso de extraccin del contorno para cada imagen. Clculo de los Descriptores de Fourier a partir del contorno de las imgenes. Construccin, entrenamiento y simulacin de la Red Neuronal; en este punto iremos modificando las caractersticas de la red neuronal (nmero de capas, nmero de neuronas, algoritmos de entrenamiento), y as obtener suficientes datos para realizar un anlisis de qu red neuronal funciona mejor como clasificador de formas. Anlisis de resultados y comparacin con los obtenidos en [marin03]. Compararemos tanto la eficiencia en la clasificacin, como los tiempos empleados en ella, as como las iteraciones necesarias para realizar un buen entrenamiento que permita obtener un clasificador eficiente.
LISTA DE ABREVIATURAS
DF RNA Descriptores de Fourier Redes Neuronales Artificiales
1. PROCESADO DE IMAGEN
Nuestro universo de entrada ser una esfera, un cubo, una llave allen y una rueda de LEGO, presentado como imgenes en escala de grises. Como se puede apreciar en la figura 1, las distintas imgenes presentarn problemas con el ruido y con las sombras debido en gran medida a la iluminacin y a la superficie donde se tomaron las muestras.
Figura 1: Universo de entrada.
Nuestro primer objetivo ser procesar la imagen para poder extraer el contorno de los objetos del universo de entrada de forma eficiente, eliminando toda informacin de la imagen que no pertenezca al propio objeto que se est analizando. Para llevar a cabo este procesado se han utilizado las funciones de tratamiento de imgenes de Matlab (Image Processing Toolbox [mathworks])
En la figura 2 se indican los pasos seguidos para procesar la imagen:
Imgen en Escala de Grises
Binarizacin
Eliminacin del Ruido
Deteccin del Contorno
Extraccin del Contorno
Coordenadas del Controno
Figura 2: Etapas del procesado de la imagen
1.1
Binarizacin (im2bw)
El primer paso del tratamiento fue la binarizacin de la imagen, de esta forma eliminaremos posibles sombras. La seleccin del umbral (0,2) fue bastante importante, ya que un umbral excesivamente alto deformaba el objeto debido a las sombras. En la figura 3 se aprecia la llave allen, de la figura 1, binarizada; se han eliminado las sombras y el efecto de la superficie, pero la imagen tiene ruido como se aprecia en la parte superior central, y en algunas zonas del contorno.
Figura 3: Llave allen binarizada
1.2
Filtrado (medfilt2)
Con el filtrado conseguiremos eliminar el ruido de la imagen. En concreto se ha aplicado un filtro no lineal, el filtro de mediana. En la figura 4 se pude observar el resultado tras aplicar el filtro.
Figura 4: Llave allen sin ruido
1.3
Deteccin del contorno (bwperim)
Indicando la vecindad la funcin bwperim de la Toolbox de Matlab nos devuelve una nueva imagen con los contornos de los objetos que haya localizado. Si la bizarizacin y el filtrado se realiz correctamente, solo tendremos un solo contorno (cerrado) en la imagen (ver figura 5).
Figura 5: Contorno de la llave allen
En el anexo B1 se incluye el cdigo en matlab para la binarizacin, filtrado y extraccin del contorno (proc_img.m). El resultado ser una matriz de 1s y 0s que representar la imagen de la figura 5.
1.4
Extraccin del contorno
Una vez detectado el contorno de la imagen, sta ser escaneada en busca del primer punto del contorno (primer pxel). A partir de este punto inicial iremos extrayendo las coordenadas de la frontera en orden, hasta regresar a este punto (el contorno debe ser cerrado). El programa ir chequeando cada pxel y sus adyacentes para determinar la direccin correcta del contorno (se seguir el sentido de las agujas del reloj). Destaquemos que si el contorno posee cierto ruido pueden producirse ciclos infinitos al recorrer el contorno, ya que no se consigue volver al punto inicial del contorno. En el anexo B2 se adjunta el cdigo en Matlab para la extraccin de estas coordenadas, que se devolvern como dos vectores de coordenadas (xVector e yVector).
1.5
Tiempos de clculo
En la tabla 1 se puede apreciar el tiempo, en segundos, necesario para llevar a cabo la binarizacin, el filtrado, la deteccin del contorno y la extraccin del mismo. El sistema con el que se llev a cabo el clculo es un Pentium III a 500 MHz con 128 Mb de RAM.
Tabla 1: Tiempos necesarios para el procesado de la imagen
Tiempo 100 muestras Tiempo Medio (1 muestra) Llave Allen Esfera Cubo Rueda de LEGO
114.21 142.37 137.10 157.03 1.1421 1.4237 1.3710 1.5703
Estos tiempos son un poco elevados y posiblemente sea necesario realizar una revisin de los algoritmos utilizados (Image Processing Toolbox de Matlab, algoritmo de extraccin del contorno) e intentar utilizar otros ms ptimos. De momento nos quedamos con los resultados, y cara a una implementacin real ya se buscaran soluciones.
2. CLCULO DE LOS DESCRIPTORES DE FOURIER

2.1 Funcin 1-D que represente el contorno
Para poder aplicar la Trasformada Rpida de Fourier (FFT) correctamente debemos representar el contorno 2-D (vectores X e Y sacados en punto anterior) mediante una funcin con una sola variable. Ejemplos: ngulos de la frontera Coordenadas Complejas:
z ( n) = x( n) + jy ( n)
Funcin de Curvatura Distancia al Centroide: (xc, yc) es el centroide del objeto que se calcula como la media de las coordenadas de la frontera.
1 xc = N
x ( n)
n=0
N 1
1 yc = N
y ( n)
n=0
N 1
z ( n) =
( x(n) xc ) + ( y(n) yc )
2
Para este proyecto utilizaremos la funcin de Distancia al Centroide, ya que en estudios anteriores [zhang] han dado mejores resultados que las otras funciones.
2.2
Descriptores de Fourier
Para la funcin z(n) que representa el contorno, con n=0,...,N (es decir tenemos N puntos de la frontera), la Trasformada Discreta de Fourier viene dada por:
1 FDk = uk = N
z ( n) e
n =0
N 1
j 2 kn N
Los coeficientes uk son conocidos como los Descriptores de Fourier (FD) del contorno, con k=0,..., N-1.
2.2.1
Invarianza a Traslaciones, rotaciones y escalado
La invarianza a transformaciones es difcil de alcanzar en el dominio del espacio, muchas tcnicas, especialmente las de invarianza a rotacin, implican un coste computacional elevado. Sin embargo invarianza a escalado, rotacin y traslacin es sencilla de conseguir mediante los FD. Invariantes a Traslacin: la funcin 1-D elegida para representar la frontera es por s sola invariante a traslacin, ya que utiliza informacin acerca del centroide. Invariantes a Rotacin: se consigue ignorando la informacin de la fase. La Transformada Rpida de Fourier nos devuelve los descriptores como nmeros complejos, para eliminar la fase simplemente deberemos quedarnos con los valores absolutos de los FD. Invariantes a Escalado: para obtener esta propiedad simplemente dividiremos los descriptores por el primer descriptor (FD0).
Debido a la eliminacin de la informacin de la fase, nos hemos quedado con valores reales, con lo que solo tendremos N frecuencias diferentes en la transformada de Fourier, es decir,
2
solo ser necesaria la primera mitad de los FD. En el anexo B3 se adjunta el cdigo para extraer los FD a partir de los vectores de coordenadas, y como salida obtendremos el vector de descriptores, ya invariantes a traslacin, escala y rotacin.
FD FD FDN 2 1 2 , ,..., FD _ vector = FD0 FD0 FD0

Tendremos un vector de descriptores para cada una de las imgenes, en total 400 vectores de descriptores, es decir, 400 muestras que sern utilizadas para entrenar y testear la RNA. Cada muestra por su parte estar constituida por 31 DF (de los 62 calculados); nos hemos decantado por este nmero porque 15 DF (32 calculados) eran muy pocos para garantizar una buena clasificacin debido a que no se recoge suficiente informacin del contorno, y 63 DF (128 calculados) eran excesivos, aunque no se descarta en un futuro realizar pruebas con un numero elevado de descriptores para universos de entrada ms complejos que el actual.
2.2.2
Representacin de los Descriptores de Fourier para los Objetos de nuestro Universo
Figura 6: FDs para la llave allen (muestra 1)
Figura 7: FDs para la llave allen (muestra 2)
Figura 8: FDs para la esfera (muestra 1)
Figura 9: FDs para la esfera (muestra 2)
Figura 10: FDs para el cubo (muestra 1)
Figura 11: FDs para el cubo (muestra 2)
Figura 12: FDs para la rueda de LEGO (muestra 1)
Figura 13: FDs para la rueda de LEGO (muestra 2)
2.2.3
Tiempo de clculo
En la tabla 2 se puede apreciar el tiempo, en segundos, necesario para calcular los 62 Descriptores de Fourier, y aplicarles las diferentes transformaciones expuestas en 2.2.1
Tabla 2: Tiempos necesarios para el clculo de los DF
Tiempo 100 muestras Llave Allen Esfera Cubo Rueda de LEGO

0.060 0.110 0.001 0.110
Como se puede observar el tiempo de clculo necesario extraer los DF es prcticamente nulo, con lo que la eleccin de los Coeficientes de Fourier como descriptores de los objetos ha sido acertada, al menos desde el punto de vista temporal. En el siguiente punto se demostrar que tambin producen buenos resultados junto a las RNA. La velocidad de clculo de la Fast Fourier Transform (FFT) permite que se puedan usar los DF como tcnica de reconocimiento de formas en aplicaciones en tiempo real.
3. APLICACIN DE LA RED NEURONAL ARTIFICIAL COMO CLASIFICADOR DE FORMAS

3.1
3.1.1
Introduccin a las Redes Neuronales Artificiales

Definicin de Red Neuronal Artificial
Una Red Neuronal Artificial (RNA) consiste en un conjunto de unidades (neurona) simples pero muy numerosas. Cada una de estas unidades poseen muy poca memoria local, pero son muchas y estn todas interconectadas entre s a travs de canales de comunicacin o conexiones que transportan datos numricos. Por todo esto, podemos definir una RNA como un dispositivo de procesamiento, es decir, un algoritmo matemtico que se puede implementar en un programa (red neuronal en modo software) o en un montaje experimental (red neuronal en modo hardware); cuyo diseo est motivado y basado en el funcionamiento y la estructura del cerebro humano.
3.1.2
Analoga Biolgica.
Se estima que el cerebro humano consta de entre 1010 y 1011 neuronas, y alrededor de 1015 conexiones sinpticas entre ellas, con lo que cada neurona poseer entre unas 104 conexiones de entrada y salida de informacin.
Figura 14: Conexin entre Neuronas Biolgicas.
La forma que dos neuronas interactan no est totalmente conocida, dependiendo adems de cada neurona. En general, una neurona enva su salida a otras por su axn (ver figura 14). El axn lleva la informacin por medio de diferencias de potencial, u ondas de corriente, que depende del potencial de la neurona. La entrada de las seales se produce por su sinpsis, sumando todas las influencias excitadoras (la RNA lo simular mediante pesos positivos) e inhibidoras (pesos negativos). Si las influencias excitadoras positivas dominan, entonces la neurona da una seal positiva y manda este mensaje a otras neuronas por sus sinpsis de salida. En la figura 15 se aprecia un modelo de neurona artificial. sta posee una serie de entradas (x1, x2, ... , xn) que recibirn informacin de otras neuronas o de la entrada de la red. Cada una de las entradas poseer un peso (los pesos Wi definen el estado de la neurona, y en general, de la red neuronal), y sern recogidas por la funcin de red u( ), que en general se comportar como un sumatorio (
W i j X j ). La neurona se activa, enviando seal a las
j =1
neuronas vecinas, si ui es superior a un cierto nivel; esta activacin vendr dada por la funcin de activacin f( ).
Figura 15: Neurona Artificial.
3.1.3
Inters de las RNA
El gran nmero de conexiones en una RNA est en fuerte contraste con la escasa conectividad que hay en los circuitos el ectrnicos de los ordenadores actuales. Esta diferencia estructural va asociada a la distincin entre los tipos de problemas que los ordenadores convencionales y las redes neuronales pueden resolver ms eficazmente. Por ejemplo, sabemos que para realizar operaciones aritmticas los ordenadores son mucho ms eficientes que el cerebro; pero en procesos de reconocimiento, asociacin y clasificacin el cerebro supera al ms potente de los ordenadores actuales. Esta gran diferencia en las capacidades de ambos proviene de la naturaleza colectiva (paralelismo e interconectividad) del procesamiento de informacin en el cerebro, opuesta a la arquitectura segmentada y secuencial de los ordenadores convencionales.
Adems de la gran capacidad para reconocimiento, asociacin y clasificacin, las RNA poseen otras caractersticas importantes: Adaptabilidad: La capacidad de las redes neuronales para adaptar sus pesos sinpticos a cambios en el ambiente (entradas) es una herramienta muy til para realizar de forma adaptativa la clasificacin de patrones, el procesado de la seal, el control de sistemas, etc. Fiabilidad: Las RNA proporcionarn una fiabilidad de la decisin tomada. Informacin contextual: Cada neurona de la red est potencialmente afectada por la actividad de todas las dems. Implementacin VLSI: Como hemos visto las unidades de una RNA son simples, su poder est en las numerosas conexiones, esto permitir su implementacin, en modo hardware, VLSI (Very Large Scale Integration).
3.1.4
Aplicaciones de las RNA
Las RNA son aplicables en muchos y muy diferentes mbitos de las ciencias y la tecnologa. Algunos de estos campos se citan a continuacin: En visin artificial para detectar, resaltar, extraer propiedades y clasificar patrones. Todo este conjunto de etapas se denomina comnmente proceso de pattern recognition.. Procesamiento de la voz para el reconocimiento del lenguaje hablado. En Robtica permiten resolver el problema cinemtico inverso en manipuladores y robtica mvil, consistente en determinar la secuencia de movimientos que deben realizar las distintas partes del robot para alcanzar una posicin deseada. Tambin permiten el aprendizaje de la dinmica del manipulador, es decir, de la generacin de las fuerzas y pares que hay que aplicar para producir un movimiento determinado. En Medicina, para diagnosis de enfermedades Estadstica computacional, para determinar las dependencias funcionales que se deriven de sus datos de muestreo o para establecer metodologas de prediccin. Procesos qumicos, como puedan ser el control de la temperatura de un reactor qumico o el control de procesos qumico-orgnicos no lineales. Neurociencia y ciencia del conocimiento para modelar el pensamiento y la conciencia, es decir las funciones de alto nivel del cerebro. Neurofisiologa para experimentar y explotar las funciones de nivel medio del cerebro, como son la memoria, el sistema sensorial y de control, as como los procesos psicolgicos.
3.1.5
-
Modelos de Entrenamiento-Aprendizaje
Aprendizaje supervisado: Los datos para el entrenamiento estn constituidos por pares [muestra de entrada / maestro (salida deseada)]. El hecho de conocer la salida implica que el entrenamiento se beneficia de la supervisin de un maestro, y la finalidad ser minimizar el error cometido, es decir, la diferencia entre la salida producida y la deseada (maestro). Se puede ver un diagrama esquemtico de un sistema de entrenamiento supervisado en la siguiente figura:
Figura 16: Esquema aprendizaje supervisado.
Aprendizaje no Supervisado: El conjunto de datos de entrenamiento consiste slo en los patrones de entrada. Por lo tanto, la red es entrenada sin el beneficio de un maestro. La red aprende a adaptarse basada en las experiencias recogidas de los patrones de entrenamiento anteriores. En la figura 17 se puede apreciar un esquema tpico de un sistema "No Supervisado":
Figura 17: Esquema aprendizaje no supervisado.
A su vez, dentro de las dos categoras anteriores podemos distinguir entre modelos Feedforward y modelos Feedback. En los primeros el proceso de aprendizaje se divide en una o varias etapas consecutivas (el nmero de etapas depender del modelo particular), y en los segundos hay una sola etapa pero que se repite una y otra vez hasta que como salida de una iteracin se obtiene la misma respuesta que se obtena a la salida de la iteracin anterior.
En la siguiente tabla se puede observar un resumen de la clasificacin de los diferentes modelos de RNA:
Tabla 3: Modelos de RNA.
SUPERVISADO Hopfield FEEDBACK Learning Vector Quantization Boltzmann Machine Perceptron (multilayer)
NO SUPERVISADO Kohonen Self-Organizing Map Binary Adaptative Resonance Theory analog Adaptative Resonance Theory
Counter Propagation FEEDFORWARD Backpropagation Fuzzy Associative Memory ARTMAP
3.2
3.2.1
Redes Neuronales Backpropagation Multicapa no Lineales

Redes multicapa
El inters de las RNA multicapa es sencillamente por la ineficiencia de las redes monocapa. El objetivo es intentar conseguir resolver el mayor nmero de problemas posibles. Los problemas o ineficiencias de las redes monocapa se presentan a continuacin: Las redes monocapa slo dan solucin a problemas linealmente separables. No resuelven problemas tan sencillos como el OR-Exclusivo (ver figura 18) La mayora de los problemas del mundo real no son linealmente separables.
La solucin es pues, aadir ms capas; pero no de forma ilimitada. Se ha probado que un nmero excesivo de capas ocultas es improductivo. Puede ocurrir que el tiempo de convergencia en el entrenamiento de retropropagacin sea mayor, sin mejorarse las prestaciones de la red. Esto puede ocurrir por dos razones, que el error se degrade a medida que se propaga por la red y que las capas extra modifiquen la superficie de error, tendiendo a crear mnimos locales; cuando expliquemos el funcionamiento del algoritmo Backpropagation entenderemos mejor estos problemas. Por tanto, es esencial el identificar el nmero ptimo de capas en la red. En general, redes de dos capas seran adecuadas como aproximadores no lineales de cualquier funcin no lineal. Se ha demostrado que una red de tres capas es suficiente para separar cualquier regin de decisin polidrica (convexa y no convexa). En resumen, dos o tres capas son suficientes para la mayora de las aplicaciones.
En la figura 18 podemos apreciar un ejemplo de red multicapa:
Figura 19: Red Multicapa con una Capa Oculta
3.2.2
Funciones de Activacin no Lineales
Una red multicapa es capaz de aproximar cualquier funcin, siempre que las funciones de activacin sean no lineales. Si las funciones son lineales, una red multicapa se puede reducir a una red con una sola capa. En la figura 18 [galindo] podemos apreciar la importancia, a la hora de resolver diferentes problemas, del nmero de capas y de las funciones de activacin.
Figura 19: Importancia del nmero de capas y la no-linealidad
Las funciones de activacin (o funciones de neurona) que se utilizarn son las siguientes: Logsig: funcin de sigmoidal logartmica. transferencia
f ( x) =
1 1 + e ax
Figura 20: Funcin Logsig
La usaremos en la capa de salida de la red, para tener los valores de salida entre 0 y 1. Tansig: Funcin de sigmoidal tangente. transferencia
f ( x ) = tanh ( x )
La usaremos en las capas de entrad y ocultas de la red. Los valores de salida estarn comprendidos entre 1 y 1.
Figura 21: Funcin Tansig
3.2.3
Algoritmo Backpropagation
Los datos de entrada para el algoritmo de entrenamiento Backpropagation son pares entrada / maestro(salida deseada): [X, T] = {[x1, t1], [x2, t2], ... , [xn, tn]}. El objetivo del algoritmo ser encontrar pesos ptimos para cada neurona (w1, ..., wn) para minimizar el error entre los valores del maestro T y salidas para la entrada X. El entrenamiento de la RNA se reduce a un problema de optimizacin de una funcin de error de la red. Un criterio popular es minimizar los errores cuadrticos medios entre el maestro y la salida actual. El trmino Backpropagation se refiere al modo en el que se actualizan los pesos de la red, el algoritmo ajustar los pesos en la capa de salida para reducir el error y propagar los cambios realizados hacia la capa de entrada ajustando los pesos de las capas ocultas Destaquemos que los pesos se modificarn en la direccin de mximo descenso de la funcin de error (gradiente). Debido a que estamos ante un problema de optimizacin (minimizacin) y es necesario el clculo del gradiente, las funciones de activacin de las neuronas debern ser fcilmente diferenciables. Las funciones sigmoidales de tangente y logartmicas lo son con lo que no habr ningn problema en su utilizacin. El algoritmo de Retropropagacin es un algoritmo iterativo, en el que nos iremos aproximando al mnimo de la funcin. El sistema evolucionar en la direccin de la lnea de mxima pendiente (gradiente negativo). En la figura 22 [galindo] se aprecia un ejemplo de camino seguido en un proceso de optimizacin.
Figura 22: Evolucin en un proceso de optimizacin (algoritmo base)
3.2.4
Variaciones en el algoritmo base
Existen bastantes variaciones del algoritmo Backpropagation basadas en tcnicas de optimizacin estndar como puedan ser el Gradiente Conjugado o los Mtodos de Newton. La librera de Matlab para redes neuronales (Neural Network Toolbox) implementa alguna de estas variaciones. Adems existen dos formas en las que el algoritmo de descenso de gradiente puede ser implementado, en modo Batch y en modo Incremental. En modo Batch, los pesos de la red son actualizados solo cuando todo el conjunto de entrenamiento ha sido aplicado a la red, es decir, los gradientes calculados para cada muestra de entrenamiento se utilizan en conjunto para determinar los nuevos pesos y biases. Por el contrario en modo Incremental los pesos son actualizados para cada una de las muestras de entrenamiento. Los algoritmos que utiliza Matlab para entrenar Redes Backpropagation trabajan en modo Batch. A continuacin comentaremos los usados en este trabajo. 3.2.4.1 Mtodos Heursticos Variable Learning Rate Backpropagation with Momentum Training (traingdx): En el algoritmo estndar de descenso la tasa de aprendizaje se mantiene constante durante el aprendizaje. La inclusin de una tasa de aprendizaje adaptativa puede acelerar la convergencia a la solucin, pero siempre que sta posea los valores adecuados, ya que valores altos pueden producir inestabilidad y valores muy pequeos pueden hacer que el proceso de convergencia sea muy lento. Este algoritmo adems no slo utiliza informacin del gradiente local, sino tambin informacin de las direcciones tomadas recientemente. Resilient Backpropagation (trainrp): En este algoritmo, slo el signo de la derivada es utilizado para sacar la direccin de la actualizacin de los pesos, la magnitud de la misma no se utiliza en la actualizacin. El incremento o decremento de los pesos viene dado por dos variables que van tomando diferentes valores segn el estado del algoritmo. Esto permite que el algoritmo converja ms rpidamente ya que no est sujeto al valor del gradiente, solo a su signo (direccin), que puede tomar valores muy pequeos reduciendo notablemente la velocidad de la evolucin de los pesos y biases.
3.2.4.2 -
Tcnicas de Optimizacin Numrica Algoritmos de Gradiente Conjugado. Estos algoritmos se mueven por las direcciones conjugadas, que generalmente producen una convergencia ms rpida, y no en la direccin de mximo decrecimiento (gradiente negativo) que no siempre implica una convergencia ms rpida. En este proyecto se ha trabajado con cuatro variaciones del algoritmo de gradiente conjugado: o o o o Actualizacin Fletcher-Reeves (traincgf) Actualizacin Polak-Ribire (traincgp) Actualizacin Powell-Beale (traincgb) Gradiente Conjugado Escalado (trainscg)
Mtodos Quasi-Newton o de Secante. Los mtodos de Newton a menudo convergen ms rpido que los mtodos del gradiente conjugado, pero son complejos y poseen un coste computacional elevado ya que trabajan con la matriz Hessiana. Los mtodos Quasi-Newton no requieren el clculo de segundas derivadas, ya que en cada iteracin actualizan y aproximan la matriz Hessiana. En este trabajo se utiliz uno de los algoritmos: o One Step Secant Algorithm (trainoss): este algoritmo no almacena la matriz Hessiana completamente, en cada iteracin asume que la matriz Hessiana anterior fue la matriz identidad.
3.2.5
-
Factores que Influyen en el Rendimiento de la Red

Nmero de patrones: cuanto mayor sea el conjunto de muestras para el entrenamiento, mejor ser ste. En la figura 23 [galindo] se puede apreciar como la tasa de error en el conjunto de test se reduce si aumenta el nmero de muestras de entrenamiento.
Figura 23: Efecto del nmero de muestras de aprendizaje
Nmero de capas ocultas: como se introdujo en 3.2.1, el nmero mayor de capas ocultas no siempre mejoraba el rendimiento de la red. Esto puede ocurrir por dos razones, que el error se degrade a medida que se propaga por la red o debido a que las capas extra modifican la superficie de error, tendiendo a crear mnimos locales. En la figura 24 [galindo] se aprecia claramente lo explicado, buen funcionamiento, aparentemente, en el entrenamiento; pero aumento de la tasa de error, debido a que el entrenamiento realmente no fue bueno.
Figura 24: Efecto del nmero de unidades ocultas
Nmero de iteraciones: el nmero de iteraciones que efecte el correspondiente algoritmo de entrenamiento no debe ser elevado ya que se puede producir un sobreentrenamiento de la red, producindose resultados no deseados (ver figuras 25 y 26 [galindo]).
Figura 25: Efecto del nmero de iteraciones (1)
Figura 26: Efecto del nmero de iteraciones (2)
3.2.6
Problemas en el Algoritmo Backpropagation
El algoritmo Backpropagation proporciona buenos resultados, pero presenta algunos problemas bastante importantes. Lentitud en el aprendizaje: Si la pendiente de la funcin de error es escasa, el entrenamiento puede llegar a ser muy lento. Convergencia a mnimos locales: la superficie de error est llena de picos y valles, con lo que se dificulta notablemente la localizacin del mnimo global, y se suele caer en mnimos locales. Arquitectura de la red: resulta complicado seleccionar la topologa de red (nmero de capas y unidades por capa) ptima para un problema, siendo necesarias numerosas pruebas. Tambin la eleccin de los diferentes parmetros de entrenamiento (momentos, incrementos de variables, error aceptable, mnimo valor de gradiente, etc.) es bastante compleja.
3.3
3.3.1
Implementacin Software de la Red Neuronal

Fases de Procesamiento y Divisin del Conjunto de Muestras
Existen dos fases en toda aplicacin de las Redes Neuronales, una fase de aprendizaje y una fase de prueba. En la primera se usa un conjunto de datos o patrones de entrenamiento para determinar los pesos que definen el modelo neuronal. En la segunda, se procesarn los patrones de prueba que constituirn la entrada habitual de la red, analizndose de esta manera las prestaciones de la red. Nuestro conjunto de datos o patrones est formado por 100 muestras para cada objeto del universo, en total 400 muestras, de las que 300 se utilizarn para la fase de entrenamiento o aprendizaje, y 100 para la fase de test o prueba. En el anexo C1 se adjunta el cdigo para la carga de los datos con los que se trabajar.
3.3.2
Creacin de la RNA
red feed-forward parmetros son los
Utilizaremos la funcin newff para crear una (net=newff(PR,[S1,S2...SNl],{TF1,TF2...TFNl},BTF,BLF,PF)). Sus siguientes: -
PR Matriz R x 2 con los valores mximo y mnimo de las R muestras de entrada. Si Tamao de la i-sima capa para N1 capas. En este proyecto se ha trabajado con diferentes topologas, con dos, tres y cuatro capas, desde sencillas como [10 4] a ms complejas como [50 100 100 4]. La ltima capa siempre con 4 neuronas ya que es el nmero de objetos a clasificar, cada neurona de salida clasificar a uno de los objetos. TFi Funcin de Transferencia de la i-sima capa ( 'tansig' por defecto). En las pruebas realizadas se ha utilizado logsig para la ltima capa y as tener los valores de salida entre 0 y 1, y tansig para el resto de capas. BTF Funcin de entrenamiento de la Red ('traingdx' por defecto). Este parmetro es el que identificar a la red como una red feed-forward Backpropagation. En este proyecto hemos utilizado los algoritmos taringdx, trainrp, traincgf, traincgp, traincgb, trainscg y trainoss. BLF - Funcin de aprendizaje de la red ('learngdm', descenso de gradiente por defecto; no se usa en Backpropagation) PF - Funcin de Rendimiento ('mse', error cuadrtico medio por defecto)
En el anexo C2 se adjunta el cdigo para la creacin de la red.
3.3.3
Entrenamiento de la RNA
El paso previo al entrenamiento de la red fue establecer el valor de los parmetros de entrenamiento. Nmero de iteraciones mximo, en 3.2.5 ya se vio la importancia de este parmetro. Tras realizar varias pruebas el nmero de epochs mximo elegido fue 300, ya que con menos iteraciones no se obtenan buenos resultados para la mayora de algoritmos, y con ms iteraciones se haca excesivamente lento el proceso de entrenamiento. El valor mnimo del gradiente. El valor escogido fue 10-6 El valor mnimo de la funcin de error. Para valores cercanos a 10-3 los resultados de la clasificacin eran bastante buenos, con lo que se escogi este valor como mnimo de la funcin de error.
En las figuras 27 y 28 podemos apreciar que el nmero de iteraciones mximo y el valor mnimo de la funcin de error, que se han establecido, funcionan bien como criterios de parada del entrenamiento evitando el sobreentrenamiento de la red (como se vio en los ejemplos de 3.2.5). En el ejemplo de la figura 27 se alcanza el objetivo llegando a un valor de la funcin de error menor a 0.001, que era el mnimo establecido. En el ejemplo de la figura 28 si que fue necesario llegar a la iteracin 300 para obtener un buen entrenamiento de la red.
Figura 27: Ejemplo de simulacin de la red (1)
Figura 28: Ejemplo de simulacin de la red (2)
El entrenamiento de la red neuronal feed-forward se ha llev a cabo mediante la funcin de Matlab train ([net, tr] = train(net,P,T,Pi,Ai,VV,TV)). Los parmetros de entrada de la funcin se comentan a continuacin (en el anexo C1 se adjunta el cdigo para la carga de los datos con los que se trabajar). net Red Neuronal feed-forward Backpropagation P Entradas de la Red Neuronal. Sern las 300 muestras de entrenamiento, 300 vectores con 31 descriptores cada uno de ellos. T Objetivos de la Red. Sern los maestros o salidas deseadas asociados a cada una de las muestras. Sern vectores de cuatro componentes: o [0.9 0.1 0.1 0.1], indicar que la muestra asociada eran descriptores de una llave allen. [0.1 0.9 0.1 0.1], la muestra asociada eran descriptores de la esfera [0.1 0.1 0.9 0.1], para el objetivo asociado a los descriptores del cubo. [0.1 0.1 0.1 0.9], para los descriptores de la rueda de LEGO.
o o o
Pi Condiciones de retardo de la entrada Ai Condiciones de retardo de la capa inicial VV Estructura de los vectores de validacin (No usado). TV Estructura de los vectores de test.
Las salidas de la funcin sern la red neuronal ya entrenada (net) y preparada para la simulacin, y el registro de entrenamiento (tr). Este registro de entrenamiento nos proporcionar informacin acerca del proceso, por ejemplo el nmero de iteraciones realizadas para entrenar la red. En el anexo C2 se adjunta el cdigo para el entrenamiento de la red neuronal.
3.3.4
Simulacin de la Red
Una vez entrenada la red se simula la red para obtener resultados acerca de la eficiencia en la clasificacin. La funcin que proporciona Matlab es simy su sintaxis es [Y, P]=sim(net,P). Los parmetros de entrada son net, que es la red ya entrenada y P que son el conjunto de muestras de test o de prueba (en nuestro caso sern 100). La funcin devolver las salidas de la red producidas para cada una de las muestras de test. En el anexo C2 se adjunta el cdigo para llevar a cabo la simulacin de la red. Cada neurona de salida devolver un valor comprendido entre 0.1 y 0.9, estos valores de salida sern comparados con los deseados, es decir, con los valores objetivo para el conjunto de prueba (el anexo C1 adjunta el algoritmo para la carga de las matrices de muestras y las de objetivos, y en el C3 el cdigo para la interpretacin de resultados). El programa principal (ver anexo C4) va construyendo diferentes topologa para cada algoritmo de entrenamiento, y simula el comportamiento de la red para el conjunto de test, almacenando los resultados en ficheros. Destaquemos que adems de la eficiencia de la clasificacin, tambin se almacenan datos acerca del nmero de iteraciones realizadas y del tiempo empleado en la simulacin. En los siguientes puntos se presentan los resultados obtenidos para cada uno de los algoritmos con diferentes topologas. Destaquemos que para cada topologa se entren y simul la red dos veces, para obtener un resultado un poquito ms fiable.
3.3.4.1
Resultados obtenidos para el algoritmo traingdx Porcentaje Aciertos

44.50 67.50 75.50 80.00 57.00 65.50 69.00 56.00 68.50 69.50 62.00 46.50 71.50 80.00 51.00 68.00 64.50 78.50 61.50 59.00 84.00 71.00 67.00 81.00 62.00 70.50 75.00 79.50 54.50 72.50 69.50 77.00
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0300 0.0550 0.0300 0.0000 0.0000 0.0000 0.0250 0.0000 0.0300 0.0500 0.0550 0.0300 0.0250 0.0600 0.0250 0.0300 0.0550 0.0600 0.0800 0.0550 0.0000 0.0800 0.0300 0.0500 0.0600 0.0500 0.0800 0.0550 0.0850 0.0600 0.0800 0.0800
Iteraciones
300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300
67.625
0.0439
300
3.3.4.2
Resultados obtenidos para el algoritmo traingrp Porcentaje Aciertos

99.00 98.50 99.00 98.00 99.00 99.50 100.00 99.00 99.00 100.00 98.50 99.00 99.00 99.00 100.00 99.00 99.50 98.50 98.50 98.50 98.50 99.00 98.00 99.00 99.00 98.50 99.00 99.50 99.50 100.00 99.50 98.50
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0000 0.0000 0.0300 0.0300 0.0300 0.1400 0.0250 0.0000 0.0800 0.0250 0.0800 0.0800 0.0300 0.0500 0.0300 0.0600 0.0300 0.0550 0.0300 0.0800 0.0800 0.0850 0.0300 0.0250 0.0250 0.0550 0.0550 0.0250 0.0500 0.0550 0.0550 0.0800
Iteraciones
300 300 300 300 300 272 300 300 214 217 300 228 281 201 267 226 186 255 289 221 192 222 226 164 236 185 154 191 209 153 188 155
99.01
0.0470
235.38
3.3.4.3
Resultados obtenidos para el algoritmo traincgf Porcentaje Aciertos

49.50 42.50 64.00 62.50 81.00 83.50 91.50 58.00 84.50 39.50 80.00 48.50 47.50 90.50 67.00 55.50 38.00 85.00 43.00 50.50 88.50 57.00 61.50 82.50 85.50 73.00 67.00 98.00 57.00 56.00 75.50 97.50
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0550 0.0250 0.0300 0.0300 0.0250 0.0550 0.0600 0.0250 0.0300 0.0250 0.0600 0.0550 0.0000 0.0000 0.0250 0.0500 0.0000 0.0500 0.0550 0.0000 0.0300 0.0300 0.0250 0.0550 0.0500 0.0000 0.0550 0.0550 0.0550 0.0800 0.1100 0.0500
Iteraciones
300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 291 300 300 300 300
67.53
0.0390
299.72
3.3.4.4
Resultados obtenidos para el algoritmo traincgp Porcentaje Aciertos

80.50 86.00 91.50 93.00 88.00 91.00 89.00 89.50 94.00 96.50 86.50 93.00 97.50 95.50 89.00 88.00 81.50 96.50 80.50 83.50 95.50 95.50 96.50 99.00 91.00 86.50 97.50 98.50 97.50 84.00 97.50 98.00
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0500 0.0550 0.0000 0.0250 0.0000 0.0550 0.0250 0.0550 0.0000 0.0250 0.0300 0.0000 0.0500 0.0550 0.0300 0.0600 0.0250 0.0500 0.0000 0.0250 0.0250 0.0250 0.0000 0.0600 0.0550 0.0500 0.0600 0.0600 0.0850 0.0500 0.0850 0.0850
Iteraciones
300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 287 300 300 300 300 300 300 300 300
91.48
0.0392
299.59
3.3.4.5
Resultados obtenidos para el algoritmo traincgb Porcentaje Aciertos

68.00 63.00 90.50 92.50 77.50 91.00 96.50 69.50 96.50 97.50 76.50 87.00 62.00 97.50 96.00 96.00 97.00 97.50 86.50 91.50 97.50 97.50 98.00 86.00 99.00 87.00 99.00 98.00 80.50 99.00 99.00 97.00
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0500 0.0550 0.0250 0.0600 0.0000 0.0000 0.0550 0.0300 0.0300 0.0500 0.0000 0.0550 0.0550 0.0550 0.0250 0.0000 0.0550 0.0300 0.0550 0.0250 0.0300 0.0600 0.0550 0.0500 0.0550 0.0600 0.0500 0.0550 0.0550 0.0800 0.0800 0.0800
Iteraciones
300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300
89.61
0.0444
300
3.3.4.6
Resultados obtenidos para el algoritmo trainscg Porcentaje Aciertos

76.00 84.50 87.00 92.00 83.50 88.50 94.50 84.00 95.00 92.00 87.00 92.00 96.00 96.00 87.00 93.00 95.50 96.50 67.00 87.50 96.00 98.00 98.50 97.50 93.00 98.00 95.50 96.00 95.00 92.00 96.00 96.50
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0300 0.0000 0.0250 0.0800 0.0850 0.0300 0.0800 0.0300 0.0000 0.0250 0.0300 0.0250 0.0550 0.0300 0.1150 0.0300 0.1350 0.0600 0.1100 0.0550 0.0250 0.0250 0.0550 0.1400 0.0600 0.0550 0.0800 0.1400 0.1650 0.0850 0.0850 0.1100
Iteraciones
300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300
91.45
0.0642
300
3.3.4.7
Resultados obtenidos para el algoritmo trainoss Porcentaje Aciertos

50.50 78.00 85.00 87.50 76.50 84.00 85.00 73.50 86.00 86.50 84.00 86.50 89.50 92.50 78.50 86.00 90.50 89.50 81.00 84.50 94.50 83.00 91.50 96.50 86.00 88.50 93.50 92.00 73.50 91.00 92.00 88.00
Topologa
[10 4] [20 4] [50 4] [100 4] [10 10 4] [10 20 4] [20 20 4] [10 40 4] [20 40 4] [30 40 4] [10 60 4] [20 60 4] [30 60 4] [50 60 4] [10 100 4] [20 100 4] [30 100 4] [50 100 4] [10 10 10 4] [10 20 20 4] [20 20 20 4] [10 40 40 4] [20 40 40 4] [30 40 40 4] [10 60 60 4] [20 60 60 4] [30 60 60 4] [50 60 60 4] [10 100 100 4] [20 100 100 4] [30 100 100 4] [50 100 100 4]
Tiempo (Segundos)
0.0550 0.0300 0.0250 0.0250 0.0850 0.0300 0.0000 0.0300 0.0250 0.0000 0.0550 0.0550 0.0000 0.0550 0.0250 0.0300 0.0600 0.0550 0.0300 0.0550 0.0000 0.0300 0.0550 0.0550 0.0550 0.0250 0.0600 0.1100 0.0850 0.1650 0.1100 0.1700
Iteraciones
300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300 300
85.16
0.0514
300
3.3.5
-
Anlisis de los Resultados

Algoritmo traingdx: no produce resultados excesivamente buenos, quiz porque 300 iteraciones sean insuficientes para converger a una buena solucin, es decir, a un buen entrenamiento. Destaquemos la mejora de resultados con el aumento de complejidad en la topologa de la red. Algoritmo trainrp: sin duda es el algoritmo que mejores resultados proporciona, para cualquier topologa, alcanzando una eficiencia del 100% en alguno de los casos, aunque sera ms apropiado garantizar realmente un 98% o 99% de acierto. Destaquemos que para topologas complejas (ms capas y ms neurona) se converge ms rpidamente, reducindose el nmero de neuronas necesarias. En la figura 29 podemos ver la relacin entre el nmero de capas y la convergencia a la solucin, para el algoritmo trainrp. Con tres capas se producen ya muy buenos resultados tanto en la convergencia como en la eficiencia de la clasificacin, el aadir una cuarta capa mejora la convergencia (se reduce el nmero de iteraciones); pero ya vimos en 3.2.1 que excesivas capas podan ampliar el tiempo necesario por iteracin, y podan hacer caer al algoritmo en mnimos locales, al complicar la funcin de error.
Figura 29: Importancia del nmero de capas en la convergencia
La figura 30 muestra por su parte la relacin entre nmero de neuronas en capas ocultas y el nmero de iteraciones realizadas. Segn la grfica, con ms neuronas en las capas ocultas se converge ms rpido; pero se debera estudiar con mayor detenimiento el intervalo de neuronas entre 60 y 100, para concluir algo definitivo.
Figura 30: Importancia del nmero de neuronas en capas ocultas para la convergencia
La figura 31 muestra la influencia del nmero de neuronas en la capa inicial y el nmero de iteraciones realizadas. Se puede observar como con 20 y 30 neuronas en la capa inicial se converge ms rpido, pero el aadir ms neuronas a la capa no se obtienen mejores resultados. En [tolstoy02] se lleg a una conclusin semejante, en el sentido de que por ms neuronas que haya en la capa inicial no se converge siempre ms rpido. Podemos concluir que el valor ptimo para el nmero de neuronas de la capa inicial se encuentra en intervalo (20, 40).
Figura 31: Importancia del nmero de neuronas en la capa inicial para la convergencia
Algoritmo traincgf: este algoritmo es el ms irregular de los siete con los que se ha trabajado. Esta irregularidad en los resultados puede ser debida a la tendencia del algoritmo a caer en mnimos locales, entrenndose de forma ineficiente la red. Aunque tampoco se descarta el que se produzca un ligero sobreentrenamiento que haga que los resultados no sean los esperados y deseados. Algoritmos traincgp, traincgb y trainscg: estos tres algoritmos de Gradiente Conjugado tienen un comportamiento bastante parecido ante las topologas seleccionadas. Para topologas sencillas (pocas neuronas en la capa de entrada y pocas neuronas en capas ocultas) no producen muy buenos resultados, siendo bastante malos, en general, cuando solo se tienen 10 neuronas en la capa de entrada. Respecto a la convergencia, son ms lentos que trainrp, ya que a partir de las 250300 iteraciones es cuando empiezan a converger bien par la mayora de topologas. Algoritmo trainoss: posee un comportamiento anlogo a los anteriores; pero converge de forma ms lenta. Siendo 300 iteraciones insuficientes para la mayora de topologas.
Respecto a los tiempos necesarios para la simulacin, stos son bastantes bajos para los siete algoritmos. El mximo producido para topologas complejas, supera ligeramente la dcima de segundo; pero de media se mantiene siempre por debajo de los 70 milisegundos. Podemos concluir que la eleccin de redes neuronales como clasificadores es buena para problemas en tiempo real, tanto por su eficiencia como por su velocidad.
3.3.6
Comparacin de Resultados con trabajos anteriores.
En [marin03] se utilizaron los siguientes descriptores: Descriptores HU de superficie y HU de borde. Relacin entre permetro y superficie. Relacin entre ejes de mnima y mxima inercia. Relacin entre ejes y superficie.
Los resultados obtenidos se presentan en la siguiente tabla.

Tabla 4: Resultados obtenidos en [marin03]
Topologa Algoritmo
Trainrp Trainscg Traincgf Traincgb Trainoss
[10 4]
92.20 94.40 84.30 92.20 91.60
[50 4]
94.20 94.20 87.00 88.40 89.40
[10 10 4]
93,00 92.90 84.00 92.00 93.80
[100 100 4]
95.70 92.20 89.20 92.90 93.60
Con topologas sencillas se obtuvieron mejores resultados en [marin03], para los algoritmos de Gradiente Conjugado y de Secante; pero con topologas ms complejas con los algoritmos trainscg y traincgb se han mejorado los resultados de forma notable. Para el caso del algoritmo trainoss, se consigue una eficiencia bastante similar. Por contra el algoritmo traincgf en [marin03] dio unos resultados aceptables cosa que no ha ocurrido en este trabajo. Pero sin duda lo ms positivo es que con trainrp se han mejorado los resultados para todas las topologas alcanzndose una media de acierto del 99%. Respecto a los tiempos necesarios para la simulacin, los resultados obtenidos han sido semejantes a los de [marin03], utilizndose un sistema semejante al de este proyecto.
4. CONCLUSIONES Y TRABAJO FUTUROEn este proyecto

se ha estudiado la posibilidad de utilizar los Descriptores de Fourier junto a las Redes Neuronales Artificiales para el reconocimiento de formas; y se ha llegado a unos muy buenos resultados tanto en tiempo (retardos prcticamente nulos debido al clculo del los Coeficientes de Fourier y a la simulacin de la red) como en eficiencia, ya que con el algoritmo Resilient Backpropagation (trainrp) se puede garantizar un porcentaje de acierto superior al 98% con la topologa adecuada. Como topologa ptima no se puede seleccionar una en concreto, pero s una aproximacin: con tres capas, de 25 a 35 neuronas en la capa de entrada y de 600 a 100 en la capa oculta. Como trabajo futuro se proponen varios puntos: Seleccin de un universo ms complejo. Este sencillo universo de entrada nos ha sido bastante til para comprobar el buen funcionamiento de los Descriptores de Fourier; pero se queda pequeo en comparacin con casos reales. Ampliacin de los descriptores. La eleccin de un universo de entrada ms complejo puede hacer necesaria la inclusin de nuevos descriptores, para detectar agujeros, diferentes estados de un objeto (unas tijeras puedes estar abiertas o cerradas), etc. Otra posibilidad sera el multiplicar el nmero de DF a utilizar, pasando de 31 a 63 descriptores. Analizar nuevos modelos de red. Las redes Backpropagation han dado buenos resultados; pero ya se ha visto que los algoritmos de entrenamiento tienen problemas con los mnimos locales y con la velocidad de convergencia, y puede que un universo ms complejo haga que la funcin de error se complique en exceso. Implementacin Hardware de la Red. Ante aplicaciones que precisen alta velocidad de decisin, puede que sea necesaria una implementacin Hardware de la Red.
ANEXOS
A. LISTA DE DOCUMENTOS DE REFERENCIA
P. L. Galindo, Curso de Redes Neuronales, Grupo de Sistemas Inteligentes de Computacin, Universidad de Cdiz, http://www2.uca.es/dept/leng_sist_informaticos/preal/pedro B. Jhne, Image Processing for Scientific Applications, pp. 495-507, 1997 R. Jain, R. Kasturi, Mavhine Vision, pp. 223-228, 1995 B.M. Jones, Using Fourier Descriptors Representation for Image Recognition, 2001 R. Marin, P.J. Sanz, J.S. Snchez, Fast Object Recognition Methods For The Uji Online Robot, Computer Science Department, Jaume-I University, 2003. http://www.mathworks.com (Matlab Reference, Image Processing Toolbox and Neural Network Toolbox) T. Petkovic, J. Krapac, Shape Description with Fourier Descriptors, 2002 I. Pitas, Digital Image Processing Algorithms, pp. 309-311, 1995 L. Tolstoy, Application of Fourier Descriptors and Neural Network to Shape Recognition, University of Puerto Rico, 2002 D. Zhang, G. Lu, A Comparative Study on Shape Retrieval Using Fourier Descriptors with Different Shape Signatures
[galindo] [jhne97] [jain95] [jones01]
[marin03]
[mathworks] [petkovic02] [pitas95] [tolstoy02] [zhang]
B. CDIGOS EN MATLAB PARA EL PROCESADO DE LA IMAGEN Y LA EXTRACCIN DE LOS DESCRIPTORES DE FOURIER

B.1. PROCESADO DE LA IMAGEN: Binarizacin, Filtrado y Deteccin del Contorno (proc_img.m)
function imgperim=proc_img(originalImg) %Procesara la imagen para sacra el perimetro de la misma de forma %eficiente. %Binarzamos, cogemos como umbral 0.2, que el que mejor se adapta %para eliminar sombras bw1 = im2bw(originalImg, 0.2); %figure;imshow(bw1); %Pasamos filtro de mediana -->Perform two-dimensional median %filtering.Each output pixel contains the median value in the 5%by-5 neighborhood around the corresponding pixel in the input %image bw1 = medfilt2(bw1, [4, 4]); %figure;imshow(bw1); %Eliminamos posibles puntos del exterior, que puedan influir en %el trazado del contorno [rows, columns] = size(bw1); for l = 1:rows, bw1(l,1)=1; bw1(l,320)=1; bw1(l,2)=1; bw1(l,319)=1; end for m = 1:columns, bw1(1,m)=1; bw1(2,m)=1; bw1(240,m)=1; bw1(239,m)=1; end %figure;imshow(bw1); %Sacamos el perimetro de la imagen, con vecindad 4 imgperim = bwperim(bw1, 4); %figure;imshow(imgperim); %La funcion bwperim genera un contorno exterior que representa a %la propia imagen %Este contorno puede estorbarnos cuando saquemos los puntos del %contorno para objetos cercanos a los bordes. for l = 1:rows, imgperim(l,1)=0; imgperim(l,320)=0; end for m = 1:columns, imgperim(1,m)=0; imgperim(240,m)=0; end
%figure;imshow(imgperim);
B.2.
PROCESADO DE LA IMAGEN: Extraccin de las Coordenadas del Contorno (SacaContorno.m)
function [xVector, yVector]=SacaContorno(imgperim) %Esta funcion recibira como parametro de entrada la imagen tras ser %procesada (binarizada, filtrada, y sacado su perimetro) %Devolvera los vectores de contorno, correspondientes a los puntos (x,y)
[rows, columns] = size(imgperim); found = 0; for l = 1:rows, for m = 1:columns, %Buscamos primer punto del contorno del objeto %Las condiciones sobre l y m son par que no coga %info de contorno de la propia imagen if (imgperim(l,m) == 1) & (l>3) & (m > 3) & (l<237) & (m<317) found = 1; break; end end if found == 1, break; end end
%bwcontour ser nuestro vector de contorno bwcontour = [m ; l]; %Aadimos primer punto del contorno %'m' representa las columnas -> nuestro futuro vector X %'l' representa las filas --> nuestro futuro vector Y mOrig = m; lOrig = l; endofimage = 0; dir = 0; found = 0; %Vamos sacando puntos del contorno de la imagen, siguiendo siempre el sentido %de las agujas del reloj while endofimage == 0, if (m > 1) & (found == 0), if ((imgperim(l, m-1) == 1) & (dir ~= 5)), dir = 1; found = 1; end end if (l < rows) & (m > 1) & (found == 0), if ((imgperim(l+1, m-1) == 1) & (dir ~= 6)), dir =2; found = 1;
end end if (l < rows) & (found == 0), if ((imgperim(l+1, m) == 1) & (dir ~= 7)), dir = 3; found = 1; end end if (l < rows) & (m < columns) & (found == 0) if ((imgperim(l+1, m+1) == 1) & (dir ~= 8)), dir = 4; found = 1; end end if (m < columns) & (found == 0), if ((imgperim(l, m+1) == 1) & (dir ~= 1)), dir = 5; found = 1; end end if (l > 1) & (m < columns) & (found == 0), if ((imgperim(l-1, m+1) == 1) & (dir ~= 2)), dir = 6; found = 1; end end if (l > 1) & (found == 0), if ((imgperim(l-1, m) == 1) & (dir ~= 3)), dir = 7; found = 1; end end if (l > 1) & (m > 1) & (found == 0), if ((imgperim(l-1, m-1) == 1) & (dir ~= 4)), dir = 8; found = 1; end end %Posibles direcciones a coger if (dir == 1), %Oeste m = m-1; elseif (dir == 2), %Sudoeste m = m-1; l = l+1; elseif (dir == 3), %Sur l = l+1; elseif (dir == 4), %Sudeste m = m+1; l=l+1; elseif (dir == 5), %Este m = m+1; elseif (dir == 6), %Nordeste m = m+1; l=l-1; elseif (dir == 7), %Norte l = l-1; elseif (dir == 8), %Noroeste m = m-1; l=l-1; else break
end %Hemos llegado al punto de partida if ((m == mOrig) & (l == lOrig)), endofimage = 1; end %Tambin almacenamos este punto, estamos ante una funcion 'periodica' %la funcion cat concatena arrays. Bwcontour tiene 2 filas y tantas columnas %como punto vayan concatenandose. 'm' ira ala fila 1 y 'l' a la 2 bwcontour = cat(2,bwcontour, [m ; l]); found = 0; end [rows,columns] = size(bwcontour); xVector = []; yVector = []; for p = 1:columns, %primera fila son puntos de X(n) %segunda fila puntos de Y(n) xVector = cat(1,xVector, bwcontour(1,p)); yVector = cat(1,yVector, bwcontour(2,p)); end %Ploteamos %figure;plot(xVector) %figure;plot(yVector) %figure;plot(xVector,yVector)
B.3.
EXTRACCIN DE LOS DESCRIPTORES DE FOURIER (SacaFDs.m)
function fdVector=SacaFDs(xVector, yVector, num) %Esta funcion recibira como parametros los vectores de contorno, correspondientes a los puntos (x,y) %Como Resultado devolvera los descriptores de fourier, tras aplicar la fft y hacer a los FD's invariantes a %traslacion, rotacion y escalado.
%Pasamos de 2-D (X e Y) a 1-D. Utilzaremos la distancia al centroide como funcion %(Xc, Yc) es el centroide, que se pude sacar como la media de las coordenadas %del contorno. Esta funcion es invariante a traslaciones xVector = xVector - mean(xVector); yVector = yVector - mean(yVector); rVector=sqrt(xVector.^2 + yVector.^2);
%Sacamos transformada de Fourier con N coeficiente/descriptores %Interesante utilizar un N multiplo de 2, ya que la funcion FFT %utiliza un algoritmo mas optimo N = num; % NOs devuelve una serie de numero complejos como descriptores fdVector = fft(rVector,N); %Hacemos los coeficientes invariantes a rotacion, ignorando informacin de fase, % esto se consigue sacando lo valores absolutos de los descriptores fdVector = abs(fdVector); %Nos quedamo con la mitad de descriptores, excepto el componente dc, es decir el %coeficiente 0, que depende solo de la posocion de la forma dc = fdVector(1); fdVector=fdVector(2:(length(fdVector)/2)); %Dividimos el vector por el dc, y asi los descriptores seran invariantes a escalado. fdVector=fdVector./dc; %PARA LA REPRESENTACIN DE LOS DESCRIPTORES %figure;stem(fdVector,'fill') %title('Representacion de los Descriptores de Fourier') %xlabel('Numero de descriptor') %ylabel('Valor')
B.4.
PROGRAMA PRINCIPAL (principalFD.m)
%PROGRAMA PRINCIPAL %Almacenaremos los FD's en ficheros. clear all; clc %despeja la ventana de comandos, y el comando clf borra la
while 1, op = menu('Selecciona el Objeto',... 'Descriptores Circle',... 'Descriptores Cube',... 'Descriptores Allen',... 'Descriptores Wheel',... 'Salir');
if op == 1, outName = 'CircleOut'; name1 = 'circle'; elseif op == 2, outName = 'CubeOut'; name1 = 'cube'; elseif op == 3, outName = 'AllenOut'; name1 = 'allen'; elseif op == 4, outName = 'WheelOut'; name1 = 'wheel'; elseif op == 5, break; end op = menu('Numero de descriptores',... '16',... '32',... '64'); if op == 1, num = 16; elseif op == 2, num = 32; elseif op == 3, num = 64; else num = 64; end outTiempo = strcat(outName, int2str(num),'Time.m'); outName = strcat(outName, int2str(num), '.m'); fid = fopen(outName,'w'); fid2 = fopen(outTiempo,'w'); t_pimgtotal = 0; t_fdtotal = 0; t_total = cputime;
tic; for i = 1:100, %Abrimos la imagen if i < 10, name = strcat(name1, '0', int2str(i)); else name = strcat(name1, int2str(i)); end t_pimg = cputime; %Scamos tiempo de proceso de imagen originalImg = imread(name,'jpg'); %Procesamos imagen y sacamos perimetro imgperim = proc_img(originalImg); %Sacamos vectores de controno [xVector, yVector]=SacaContorno(imgperim); ecpu = cputime-t_pimg; t_pimgtotal = ecpu + t_pimgtotal; count=fprintf(fid2,'%s\n', name); count=fprintf(fid2,'Tiempo Proceso Imagen: %1.5f\n', ecpu); t_fd = cputime; %Scamos tiempo de FD %sacamos Fd's fdVector = SacaFDs(xVector, yVector, num); ecpu = cputime-t_fd; t_fdtotal = t_fdtotal + ecpu; count=fprintf(fid2,'Tiempo sacar FD: %1.5f\n\n', ecpu); %Almacenamos en Fichero count=fprintf(fid,'%s\t', name1); for j = 1:length(fdVector)-1, count=fprintf(fid,'%2.8f\t',fdVector(j)); end count=fprintf(fid,'%2.8f %s\n',fdVector(j), name); name end count = fprintf(fid2, 'Tiempo de CPU total para el Procesado de Imagen: %3.5f\n', t_pimgtotal); count = fprintf(fid2, 'Tiempo de CPU total para calculo de FD: %3.5f\n', t_fdtotal); ecpu = cputime-t_total; count = fprintf(fid2, 'Tiempo de CPU total: %3.5f\n', ecpu); et = toc; count = fprintf(fid2, 'Elapsed Time total: %3.5f\n', et); fclose(fid); fclose(fid2); end
C. CDIGOS EN MATLAB PARA LA CONSTRUCCIN, ENTRENAMIENTO Y SIMULACIN DE LA RED NEURONAL

C.1. CARGA DEL CONJUNTO DE DESCRIPTORES PARA ENTRENAR Y TESTEAR LA RED NEURONAL (carga_data.m)
function [m_train, t_train, m_test, t_test, resp_test]= carga_data(n_desc, tam_train, tam_test) if n_desc==32 m_train=zeros(15, tam_train); t_train=zeros(4, tam_train); m_test=zeros(15, tam_test); t_test=zeros(4, tam_test); resp_test=zeros(1, tam_test); fid1=fopen('AllenOut32.m', 'r'); fid2=fopen('CircleOut32.m', 'r'); fid3=fopen('CubeOut32.m', 'r'); fid4=fopen('WheelOut32.m', 'r'); size_lee=15; elseif n_desc==64 m_train=zeros(31, tam_train); t_train=zeros(4, tam_train); m_test=zeros(31, tam_test); t_test=zeros(4, tam_test); resp_test=zeros(1, tam_test); fid1=fopen('AllenOut64.m', 'r'); fid2=fopen('CircleOut64.m', 'r'); fid3=fopen('CubeOut64.m', 'r'); fid4=fopen('WheelOut64.m', 'r'); size_lee=31; end %La %la %la %la %la salida de 1 estara 2 estara 3 estara 4 estara la red neuronal seran 4 neurona, unida a la llave allen [0.9 0.1 0.1 0.1] unida al circle [0.1 0.9 0.1 0.1] unida al cube [0.1 0.1 0.9 0.1] unida a wheel [0.1 0.1 0.1 0.9]
%DATOS ENTRENAMIENTO j=1; while j <= (tam_train - 3) %Leemos de ficheros de descriptores de muestras de allen t_train(:,j)=transpose([0.9 0.1 0.1 0.1]); muestra=fscanf(fid1, '%s', 1); m_train(:,j)=fscanf(fid1, '%lg', size_lee); muestra=fscanf(fid1, '%s', 1); %Leemos de ficheros de descriptores de muestras de circle j=j+1; t_train(:,j)=transpose([0.1 0.9 0.1 0.1]);
muestra=fscanf(fid2, '%s', 1); m_train(:,j)=fscanf(fid2, '%lg', size_lee); muestra=fscanf(fid2, '%s', 1); %Leemos de ficheros de descriptores de muestras de cube j=j+1; t_train(:,j)=transpose([0.1 0.1 0.9 0.1]); muestra=fscanf(fid3, '%s', 1); m_train(:,j)=fscanf(fid3, '%lg', size_lee); muestra=fscanf(fid3, '%s', 1); %Leemos de ficheros de descriptores de muestras de wheel j=j+1; t_train(:,j)=transpose([0.1 0.1 0.1 0.9]); muestra=fscanf(fid4, '%s', 1); m_train(:,j)=fscanf(fid4, '%lg', size_lee); muestra=fscanf(fid4, '%s', 1); j=j+1; end %DATOS TEST (resp_test con valores 1, 2, 3, 4 pa poder comparar posteriormente) j=1; while j <= (tam_test - 3) %Leemos de ficheros de descriptores de muestras de allen t_test(:,j)=transpose([0.9 0.1 0.1 0.1]); resp_test(j)=1; %Allen muestra=fscanf(fid1, '%s', 1); m_test(:,j)=fscanf(fid1, '%lg', size_lee); muestra=fscanf(fid1, '%s', 1); %Leemos de ficheros de descriptores de muestras de circle j=j+1; t_test(:,j)=transpose([0.1 0.9 0.1 0.1]); resp_test(j)=2; %Circle muestra=fscanf(fid2, '%s', 1); m_test(:,j)=fscanf(fid2, '%lg', size_lee); muestra=fscanf(fid2, '%s', 1); %Leemos de ficheros de descriptores de muestras de cube j=j+1; t_test(:,j)=transpose([0.1 0.1 0.9 0.1]); resp_test(j)=3; %Cube muestra=fscanf(fid3, '%s', 1); m_test(:,j)=fscanf(fid3, '%lg', size_lee); muestra=fscanf(fid3, '%s', 1); %Leemos de ficheros de descriptores de muestras de wheel j=j+1; t_test(:,j)=transpose([0.1 0.1 0.1 0.9]); resp_test(j)=4; %Wheel muestra=fscanf(fid4, '%s', 1); m_test(:,j)=fscanf(fid4, '%lg', size_lee); muestra=fscanf(fid4, '%s', 1); j=j+1; end
C.2.
CONSTRUCCIN, ENTRENAMIENTO Y SIMULACIN DE LA RED (red_train.m)
function [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train) %Red Fedforward net = newff(minmax(m_train), topologia, trans_functions, algo_train); net=init(net); net.trainparam.epochs = 300; net.trainparam.show = NaN; net.trainparam.goal = 1e-3; %net.trainparam.min_grad=1e-6; %Parametros propios de este algoritmo if strcmp(algo_train, 'traingdx') net.trainparam.lr = 0.05; net.trainparam.lr_inc = 1.05; net.trainparam.mc = 0.9; end TV.P = m_test; TV.T = t_test; %[net, tr] = train(net,P,T,Pi,Ai,VV,TV) takes optional structures of validation and test vectors, %net - New network. %TR - Training record (epoch and perf). %P - Network inputs. %T - Network targets, default = zeros. %Pi - Initial input delay conditions, default = zeros. %Ai - Initial layer delay conditions, default = zeros %VV.P, TV.P - Validation/test inputs. %VV.T, VV.T - Validation/test targets, default = zeros. %VV.Pi, VV.Pi - Validation/test initial input delay conditions, default= zeros. %VV.Ai, VV.Ai - Validation/test layer delay conditions, default = zeros. [net , tr] = train(net, m_train, t_train, [], [],[], TV); %SACAMOS NUMERO DE ITERACIONES NECESARIAS iteraciones=tr.epoch(length(tr.epoch)); %Tiempo necesario pa la simulacion t = cputime; tic; simulation = sim(net, m_test); ecpu = cputime-t; et = toc;
C.3.
FUNCIN PARA (resultados.m)
LA
INTERPRETACIN
DE
RESULTADOS
function porcentaje_aciertos = resultados(simulation,resp_test,tam_test) %Resultado de la simulacion, pasamos a valores 1, 2, 3 ,4, 5 result=zeros(1, tam_test); for j=1:tam_test if (simulation(1, j)> 0.6) & (simulation(2, j)< 0.4) & (simulation(3, j)< 0.4) & (simulation(4, j)< 0.4) result(j)=1; %Allen elseif (simulation(2, j)> 0.6) & (simulation(1, j)< 0.4) & (simulation(3, j)< 0.4) & (simulation(4, j)< 0.4) result(j)=2; %Circle elseif (simulation(3, j)> 0.6) & (simulation(1, j)< 0.4) & (simulation(2, j)< 0.4) & (simulation(4, j)< 0.4) result(j)=3; %Cube elseif (simulation(4, j)> 0.6) & (simulation(1, j)< 0.4) & (simulation(2, j)< 0.4) & (simulation(3, j)< 0.4) result(j)=4; %Wheel else result(j)=5; end end %Comparamos resultados obtenidos, con los que deba salir n=0; for(j=1:tam_test) if result(j)==resp_test(j) n=n+1; end end porcentaje_aciertos = (n/tam_test)*100;
C.4.
PROGRAMA PRINCIPAL (principalANN.m)
%Programa principal clear all; clc %despeja la ventana de comandos, y el comando clf borra la
while 1, op = menu('Numero de descriptores',... '32 (Trabajaremos con 15 descriptores diferentes)',... '64 (Trabajaremos con 31 descriptores diferentes)',... 'Salir'); if op == 1, n_desc=32; elseif op == 2, n_desc=64; elseif op == 3, break; end
op = menu('Selecciona el algoritmo de entrenamiento',... 'Traingdx (Tasa de Aprendizaje Adaptativa con Momento)',... 'Trainrp (Resilient Backpropagation)',... 'Traincgp (Conjugate Gradient Polak-Ribiere)',... 'Traincgb (Conjugate Gradient Powell-Beale)',... 'Traincgf (Conjugate Gradient Fletcher-Reeves)',... 'Trainscg (Scaled Conjugate Gradient)',... 'Trainoss (Quasi-Newton, One step Secant)',... 'Salir'); if op == 1, algo_train = elseif op == 2, algo_train = elseif op == 3, algo_train = elseif op == 4, algo_train = elseif op == 5, algo_train = elseif op == 6, algo_train = elseif op == 7, algo_train = elseif op == 8, break; end
'traingdx' 'trainrp' 'traincgp' 'traincgb' 'traincgf' 'trainscg' 'trainoss'
op = menu('Numero de capas',... '2 (Topologia [in out])',... '3 (Topologia [in hidden out])',... '4 (Topologia [in hidden1 hidden2 out])',... 'Todas las Topologas',... 'Salir');
tam_train=300; tam_test=100; [m_train, t_train, m_test, t_test, resp_test]= carga_data(n_desc, tam_train, tam_test); %Salida siempre 4, pa poder clasificar w = 4; %[x y y w] if op == 1, %PARA DOS CAPAS capas=2; %Fichero de resultados para algoritmo con diferentes topologias outName = strcat(int2str(capas), algo_train, int2str(n_desc),'.m'); fid = fopen(outName,'w'); x=[10 20 50 100]; trans_functions = {'tansig', 'logsig'}; for i=1:length(x) topologia = [x(i) w] %Sacamos media para la topologia seleccionada aciertos = 0; et1 = 0; ecpu1 = 0; it=0; for (j=1:2) [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train); porcentaje_aciertos = resultados(simulation,resp_test,tam_test); ecpu1 = ecpu + ecpu1; et1 = et + et1; aciertos = porcentaje_aciertos + aciertos; it = iteraciones + it; end aciertos = aciertos/2 ecpu1 = ecpu1/2; et1 = et1/2; it = it/2; count=fprintf(fid,'[%d %d] -> \t', x(i), w); count=fprintf(fid,'%3.2f\t\t',aciertos); count=fprintf(fid,'TCPU: %3.5f\t Elapsed: %3.5f\t\t',ecpu1, et1); count=fprintf(fid,'Epochs: %3.0f\n',it); end fclose(fid);
elseif op == 2, %PARA TRES CAPAS capas=3; %Fichero de resultados para algoritmo con diferentes topologias outName = strcat(int2str(capas), algo_train, int2str(n_desc),'.m');
fid = fopen(outName,'w'); x=[10 20 30 50]; y=[10 20 40 60 100]; trans_functions = {'tansig', 'tansig', 'logsig'}; for k=1:length(y) for i=1:length(x) if x(i)<=y(k) topologia = [x(i) y(k) w] %Sacamos media para la topologia seleccionada aciertos = 0; et1 = 0; ecpu1 = 0; it=0; for (j=1:2) [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train); porcentaje_aciertos = resultados(simulation,resp_test,tam_test); ecpu1 = ecpu + ecpu1; et1 = et + et1; aciertos = porcentaje_aciertos + aciertos; it = iteraciones + it; end aciertos = aciertos/2 ecpu1 = ecpu1/2; et1 = et1/2; it = it/2; count=fprintf(fid,'[%d %d %d] -> \t', x(i), y(k), w); count=fprintf(fid,'%3.2f\t\t',aciertos); count=fprintf(fid,'TCPU: %3.5f\t Elapsed: %3.5f\t\t',ecpu1, et1); count=fprintf(fid,'Epochs: %3.0f\n',it); end end end fclose(fid);
elseif op == 3, %PARA CUATRO CAPAS capas=4; %Fichero de resultados para algoritmo con diferentes topologias outName = strcat(int2str(capas), algo_train, int2str(n_desc),'.m'); fid = fopen(outName,'w'); x=[10 20 30 50]; y=[10 20 40 60 100]; trans_functions = {'tansig', 'tansig', 'tansig', 'logsig'}; for k=1:length(y)
for i=1:length(x) if x(i)<=y(k) topologia = [x(i) y(k) y(k) w] %Sacamos media para la topologia seleccionada aciertos = 0; et1 = 0; ecpu1 = 0; it=0; for (j=1:2) [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train); porcentaje_aciertos = resultados(simulation,resp_test,tam_test); ecpu1 = ecpu + ecpu1; et1 = et + et1; aciertos = porcentaje_aciertos + aciertos; it = iteraciones + it; end aciertos = aciertos/2 ecpu1 = ecpu1/2; et1 = et1/2; it = it/2; count=fprintf(fid,'[%d %d %d %d] -> \t', x(i), y(k), y(k), w); count=fprintf(fid,'%3.2f\t\t',aciertos); count=fprintf(fid,'TCPU: %3.5f\t Elapsed: %3.5f\t\t',ecpu1, et1); count=fprintf(fid,'Epochs: %3.0f\n',it); end end end fclose(fid);
elseif op ==4, %TODAS LAS TOPOLOGIAS %Fichero de resultados para algoritmo con diferentes topologias outName = strcat('AllTopology_', algo_train, int2str(n_desc),'.m'); fid = fopen(outName,'w'); %---------%Para Dos %---------x=[10 20 50 100]; trans_functions = {'tansig', 'logsig'}; for i=1:length(x) topologia = [x(i) w] %Sacamos media para la topologia seleccionada aciertos = 0; ecpu1 = 0;
et1 = 0; it=0; for (j=1:2) [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train); porcentaje_aciertos = resultados(simulation,resp_test,tam_test); ecpu1 = ecpu + ecpu1; et1 = et + et1; aciertos = porcentaje_aciertos + aciertos; it = iteraciones + it; end aciertos = aciertos/2 ecpu1 = ecpu1/2; et1 = et1/2; it = it/2; count=fprintf(fid,'[%d %d] -> \t', x(i), w); count=fprintf(fid,'%3.2f\t\t',aciertos); count=fprintf(fid,'TCPU: %3.5f\t Elapsed: %3.5f\t\t',ecpu1, et1); count=fprintf(fid,'Epochs: %3.0f\n',it); end %---------%Para tres %---------x=[10 20 30 50]; y=[10 20 40 60 100]; trans_functions = {'tansig', 'tansig', 'logsig'}; for k=1:length(y) for i=1:length(x) if x(i)<=y(k) topologia = [x(i) y(k) w] %Sacamos media para la topologia seleccionada ecpu1 = 0; et1 = 0; aciertos = 0; it=0; for (j=1:2) [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train); porcentaje_aciertos = resultados(simulation,resp_test,tam_test); ecpu1 = ecpu + ecpu1; et1 = et + et1; aciertos = porcentaje_aciertos + aciertos; it = iteraciones + it; end aciertos = aciertos/2 ecpu1 = ecpu1/2; et1 = et1/2; it = it/2; count=fprintf(fid,'[%d %d %d] -> \t', x(i), y(k), w);
count=fprintf(fid,'%3.2f\t\t',aciertos); count=fprintf(fid,'TCPU: %3.5f\t Elapsed: %3.5f\t\t',ecpu1, et1); count=fprintf(fid,'Epochs: %3.0f\n',it); end end end %----------%Para cuatro %----------x=[10 20 30 50]; y=[10 20 40 60 100]; trans_functions = {'tansig', 'tansig', 'tansig', 'logsig'}; for k=1:length(y) for i=1:length(x) if x(i)<=y(k) topologia = [x(i) y(k) y(k) w] %Sacamos media para la topologia seleccionada aciertos = 0; et1 = 0; ecpu1 = 0; it=0; for (j=1:2) [simulation, ecpu, et, iteraciones] = red_train(m_train, t_train, m_test, t_test, topologia, trans_functions, algo_train); porcentaje_aciertos = resultados(simulation,resp_test,tam_test); ecpu1 = ecpu + ecpu1; et1 = et + et1; aciertos = porcentaje_aciertos + aciertos; it = iteraciones + it; end aciertos = aciertos/2 ecpu1 = ecpu1/2; et1 = et1/2; it = it/2; count=fprintf(fid,'[%d %d %d %d] -> \t', x(i), y(k), y(k), w); count=fprintf(fid,'%3.2f\t\t',aciertos); count=fprintf(fid,'TCPU: %3.5f\t Elapsed: %3.5f\t\t',ecpu1, et1); count=fprintf(fid,'Epochs: %3.0f\n',it); end end end fclose(fid); elseif op == 5, break; end end %El del while

Ok - BPN

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ok - BPN

Cargado por

Copyright:

Formatos disponibles

FD_ANN.

doc 20 de diciembre de 2006

PROYECTOS INTELIGENTES E67

APLICACIN DE DESCRIPTORES DE FOURIER Y REDES NEURONALES ARTIFICIALES PARA EL RECONOCIMIENTO DE FORMAS

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 2 de 62 Fecha: 20 de diciembre de 2006

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 3 de 62 Fecha: 20 de diciembre de 2006

3.3.4.2 3.3.4.3 3.3.4.4 3.3.4.5 3.3.4.6 3.3.4.7

Anlisis de los Resultados ..................................................................................40 Comparacin de Resultados con trabajos anteriores.........................................42

CONCLUSIONES Y TRABAJO FUTURO ..........................................................44

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 4 de 62 Fecha: 20 de diciembre de 2006

Ernesto Jimnez Ruiz

Desarrollo del Proyecto

Gabriel Recatal Ral Marn Pedro J. Sanz

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 5 de 62 Fecha: 20 de diciembre de 2006

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 6 de 62 Fecha: 20 de diciembre de 2006

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 7 de 62 Fecha: 20 de diciembre de 2006

Figura 1: Universo de entrada.

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 8 de 62 Fecha: 20 de diciembre de 2006

En la figura 2 se indican los pasos seguidos para procesar la imagen:

Imgen en Escala de Grises

Eliminacin del Ruido

Deteccin del Contorno

Extraccin del Contorno

Coordenadas del Controno

Figura 2: Etapas del procesado de la imagen

Figura 3: Llave allen binarizada

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 9 de 62 Fecha: 20 de diciembre de 2006

Figura 4: Llave allen sin ruido

Deteccin del contorno (bwperim)

Figura 5: Contorno de la llave allen

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 10 de 62 Fecha: 20 de diciembre de 2006

Extraccin del contorno

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 11 de 62 Fecha: 20 de diciembre de 2006

2. CLCULO DE LOS DESCRIPTORES DE FOURIER

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 12 de 62 Fecha: 20 de diciembre de 2006

Invarianza a Traslaciones, rotaciones y escalado

FD FD FDN 2 1 2 , ,..., FD _ vector = FD0 FD0 FD0

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 13 de 62 Fecha: 20 de diciembre de 2006

Representacin de los Descriptores de Fourier para los Objetos de nuestro Universo

Figura 6: FDs para la llave allen (muestra 1)

Figura 7: FDs para la llave allen (muestra 2)

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 14 de 62 Fecha: 20 de diciembre de 2006

Figura 8: FDs para la esfera (muestra 1)

Figura 9: FDs para la esfera (muestra 2)

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 15 de 62 Fecha: 20 de diciembre de 2006

Figura 10: FDs para el cubo (muestra 1)

Figura 11: FDs para el cubo (muestra 2)

APLICACIN DE DF Y RNA PARA EL RECOCIMIENTO DE FORMAS

Pgina: 16 de 62 Fecha: 20 de diciembre de 2006