1

Herramienta Matlab para el aprendizaje interactivo de métodos de reconocimiento de patrones

Titulació: Enginyeria en Automàtica i Electrònica industrial AUTOR: Miguel Monforte Artigas DIRECTOR: Eduard Llobet Valero

FECHA: Febrero / 2004

2

Índice

1 Memoria Descriptiva..........................................................................................3

1.1 Objeto del proyecto........................................................................................3 1.2 Titular.............................................................................................................3 1.2 Antecedentes..................................................................................................3 1.4 Posibles soluciones y solución adoptada........................................................4

1.5 Descripción general........................................................................................4 1.5.1 Introducción a los métodos de reconocimiento de patrones…………..4 1.5.2 Desarrollo del proyecto………………………………………………10 1.5.2.1 Método de Validación Por Partes……………………….……10 1.5.2.2 Método de Validación Bootstrap……………………………..28 1.5.2.3 Algoritmo Genético…………………………………………..35 2 Conclusiones.....................................................................................................46 3 Pliego de Condiciones......................................................................................47 4.1. Condiciones generales.................................................................................47 4.2. Condiciones económicas.............................................................................51 4.3. Condiciones facultativas..............................................................................53 4.4. Condiciones técnicas...................................................................................53 4 Anexos................................................................................................................54 5.1. Código..........................................................................................................54 5.2 Tutorial.........................................................................................................101 5.3 Prácticas.......................................................................................................113

3

1 Memoria Descriptiva

1.1 Objeto del proyecto Se trata de desarrollar métodos de validación para métodos neuronales, e integrarlos en una interficie gráfica (GUI) de Matlab. Por otro lado también se ha creado e integrado un nuevo método estadístico de reconocimiento de patrones. A su vez se ha realizado un tutorial del software elaborado y dos prácticas que servirán para la docencia de la asignatura de 5º curso de Ingeniería en Automática y Electrónica Industrial. El objetivo es que el software realizado sirva de apoyo para una mejor comprensión por parte de los alumnos de los métodos de reconocimiento de patrones. 1.2 Titular El titular del presente proyecto es: -Nombre: Escola Tècnica Superior d’Enginyeria (E.T.S.E.) Universitat Rovira i Virgili -Dirección: Av. Països Catalans, 26 Campus Sescelades 43007 Tarragona Telf: 977559610 1.3 Antecedentes Hasta el momento en la asignatura Sistemas de Percepción de 5º de IAEI se encomendaban unas prácticas al final de la asignatura relacionadas con los métodos de reconocimiento de patrones. Dichas prácticas tenían la finalidad de instruir al alumno en ese ámbito, con el handicap de que, para instruirse en la materia, tenía que realizar íntegramente toda la programación para poder analizar los resultados obtenidos cuando se aplica un método estadístico o neural a la información obtenida por múltiples sensores, con el consecuente trabajo de programación y el tiempo que todo ello conlleva. Mediante la herramienta creada esto ya no será un problema puesto que lo único que deberá hacer el alumno es introducir las medidas obtenidas por los diferentes sensores y seleccionar las diferentes opciones y métodos contenidos en los diferentes formularios que forman el proyecto.

Se ha partido de una herramienta parcialmente hecha y con algunos fallos existentes en su interficie gráfica. Lo que se ha hecho es corregir estos pequeños fallos, añadir e integrar nuevos métodos de validación a los métodos neuronales supervisados e implementar un nuevo método estadístico. Además se ha realizado un tutorial de la herramienta software y dos prácticas para que realicen los alumnos de quinto curso de Ingeniería.

4

1.4 Posibles soluciones y solución adoptada

Se podría haber realizado el proyecto con cualquier tipo de los diversos lenguajes visuales para Windows existentes en el mercado como por ejemplo: Visual C, Visual Basic, etc, pero finalmente se ha optado por realizar la programación en Matlab 6.1. La razón es muy simple; con cualquiera de los lenguajes de programación antes nombrados se hubieran tenido que desarrollar íntegramente las funciones de librería que ya nos vienen implementadas en los Toolbox de Matlab. Además se trata de un lenguaje muy similar al C, y en cuanto a la interficie gráfica (GUI) es muy intuitiva y resulta fácil integrar funciones ya realizadas en pulsadores, editbox, listbox, etc.

1.5 Descripción general

1.5.1 Introducción a los métodos de reconocimiento de patrones El campo de los métodos de reconocimiento de patrones es muy actual. Básicamente se trata de clasificar una serie de medidas a partir de la información captada por múltiples sensores para su posterior análisis. Dicha clasificación se realiza a partir de una serie de técnicas matemáticas y estadísticas. Evidentemente el uso de estas técnicas resulta más necesario e indicado cuantos más sensores tengamos. Generalmente se trata de matrices o agrupaciones de sensores. Las areas en las que se hace uso de dichas técnicas son muy numerosas, desde la inteligencia artificial donde por ejemplo los robots necesitan tomar decisiones en base a multitud de información obtenida por sus sensores, pasando por la agricultura (maduración de la fruta), en la industria química para analizar la composición de los gases, etc. Estos métodos recurren a una serie de bases de datos para finalmente clasificar las medidas en uno u otro grupo. Dicha información facilitará en gran medida las decisiones a tomar por el sistema encargado de procesar la información.

Figura 1: Etapas en el proceso de identificación de patrones Como se puede apreciar en la figura partimos de una agrupación de sensores a partir de los cuales captamos unas señales o medidas. De dichas señales realizamos una extracción de características con la finalidad de obtener información relevante para la identificación, eliminar a su vez los efectos cuantitativos respecto a los efectos cualitativos y finalmente reducir la dimensionalidad del problema. Generalmente antes de someter a los datos o medidas a un método de reconocimiento de patrones, se realiza un preprocesamiento de los datos. Mediante este preprocesamiento

MATRIZ DE SENSORES

EXTRACC. DE CARACT.

CLASIFICCIDENTIFIC. PATRON

5

se realiza una selección tanto de los sensores que vamos a tener en cuenta como de las variables. A continuación se describirán básicamente los fundamentos de cada uno de los métodos de reconocimiento patrones implementados en el software realizado y se realizará un análisis más profundo de aquellos que han sido creados o implementados con nuevos métodos de validación. Podemos agrupar los métodos de reconocimiento de patrones principalmente en 2 grupos: MÉTODOS ESTADÍSTICOS -Pca Análisis de Componentes Principales es un método de reconocimiento de patrones estadístico ya que no se basa en redes neuronales y además no supervisado puesto que no se contrastan los resultados obtenidos con las clases o targets reales a las que pertenece cada medida. La finalidad de este método es representar eficientemente los datos y reducir la dimensionalidad. Se parte de un espacio multidimensional para representar toda una serie de medidas, y el objetivo es establecer un nuevo sistema de coordenadas con menos dimensiones que el real u original, pero que aporte una información similar. Los nuevos ejes de referencia son las componentes principales, y la dirección y sentido que tendrán será hacia donde esté la máxima varianza residual. En cuanto a la disposición relativa entre ellas, serán ortogonales entre sí:

Como se puede apreciar en la fórmula superior las componentes principales equivalen a los diferentes sensores multiplicados por los loadings o pesos que tiene cada uno en los nuevos ejes de referencia. Si tenemos en cuenta muchas componentes principales entonces estamos considerando zonas de cada vez menos variabilidad, con lo cual podemos estar midiendo ruido. Por otro lado si los loadings de dos sensores son muy parecidos entonces es que ambos nos están dando información redundante con lo cual podemos prescindir de uno de ellos y entonces conservamos datos que aportan lo mismo. Finalmente en el caso en el que haya medidas que se encuentren fuera de los planos considerados, entonces es que se trata de residuos que no aportan información relevante al sistema. -Análisis de Clusters Es un método de análisis multivariable con tres objetivos: 1-.Generar información respecto a la similitud entre las medidas 2-.Agrupar las medidas en un árbol jerárquico según la similitud entre muestras 3-.Agrupar por clusters mediante la decisión previa de un umbral de agrupación

pp ssPC 1111 ... αα ++=

6

Desde el punto de vista matemático en primer lugar se seleccionan los datos a analizar, después se crea una matriz de similitudes basándose en la distancia euclidea existente entre todas las medidas que tenemos en cuenta, seguidamente se decide el número de clusters y finalmente se valida o no la solución. -Pcr Se trata de un método estadístico supervisado, lineal y no paramétrico. Se utiliza para clasificar y para realizar análisis cuantitativos mediante regresión de las variables de entrada a partir de los scores generados en un PCA. Básicamente se calcula una ecuación de regresión no usando directamente las respuestas sino usando los autovectores de PCA, con lo cual se consigue una predicción más fiable de las variables de entrada. En este caso los scores son ortogonales entre sí con lo cual no pueden darse problemas de colinealidad. Una vez obtenida la matriz no lineal aplicariamos el método MLR. -Mlr Se trata de un método estadístico, supervisado, lineal y paramétrico. Se aplica para realizar análisis cuantitativos. Partimos de una sistema lineal donde cada concentración lleva asociada unas respuestas a estímulos individuales. El objetivo es obtener una matriz que contenga la concentración de cada componente en cada medida de calibración. -Lda Linear Discriminant Analysis es un método supervisado basado en el PCA. Para distinguir las diversas clases, haremos uso de varios factores discriminantes, dichos factores serán las componentes principales que irán en el sentido de la máxima variación de las partículas. En este método a diferencia de en el PCA, en una misma componente principal o vector podemos encontrarnos con varios tramos del mismo que clasifiquen varias clases, o dicho de otra manera, en varios vectores de menor tamaño que tengan la misma dirección y el mismo sentido. -Pls Consiste en un método de calibración donde se puede predecir el comportamiento multivariable. A partir de variables latentes se captura la máxima varianza posible dentro de la matriz de respuestas originales. -Dfa Se trata de un método supervisado, lineal y paramétrico. Se aplica básicamente para realizar clasificaciones y se basa en un análisis de varianza y en un análisis cualitativo. Es similar al PCA pero en el DFA se encuentran nuevas direcciones ortogonales fruto de una combinación lineal de las variables de entrada. -Ga Algoritmo Genético es un método estadístico y no supervisado basado en la selección de variables. El problema de la previsión está codificado en cadenas binarias llamadas cromosomas, donde el valor 1 significa que la variable o gene ha sido elegida para

7

construir un modelo PLS y el valor binario 0 significa que la variable no ha sido elegida. La población inicial consiste en 256 cromosomas codificadas aleatoriamente (caso particular). El tamaño de la población es mantenido constante de generación en generación. En cada generación la estructura del modelo presentado está totalmente validado mediante métodos de validación cruzada. Cada miembro de la población consigue una posición dependiendo de lo bien que encaje, de la buena forma que tenga. Esto será evaluado como el CPRESS de la validación cruzada del modelo PLS construido usando variables puestas a 1 en el cromosoma. El cromosoma de menor CPRESS será el que mejor resolverá el problema. En cada generación la mitad de los cromosomas con menor CPRESS podrán vivir y engendrar. Parejas de dichos cromosomas son seleccionados aleatoriamente para engendrar usando una técnica de doble paso (crossover). También algunos de los genes de los cromosomas son aleatoriamente cambiados después de cada generación. Los cromosomas en mejor forma son mantenidos sin cambios en la siguiente generación (elitismo). Una iteración no es llevada a cabo hasta que la población no converge o la el máximo número de iteraciones es alcanzado. La población converge cuando el porcentaje de cromosomas duplicados en la población es alto (por ejemplo del 80%). MÉTODOS NEURONALES -Mlp Se trata de un método basado en redes neuronales, el cual es supervisado, no lineal y no paramétrico. Su función es realizar clasificaciones en cuanto a cuantificaciones. Se trata de una red unidireccional y su arquitectura típica es la siguiente:

Figura 2: Arquitectura de red MLP

Las neuronas de la capa oculta usan como regla de propagación la suma ponderada de las entradas con los pesos sinápticos wij y sobre esa suma ponderada se aplica una función de transferencia de tipo sigmoide, que es acotada en respuesta. La forma funcional de una sigmoide es del tipo:

8

Figura 3: Señal Sigmoide

El aprendizaje que se suele usar en este tipo de redes recibe el nombre de retropropagación del error (backpropagation). Como función de coste global, se usa el error cuadrático medio. -Som Se trata de una red no supervisada, o sea, se entrena sólo con patrones de entrada. Las entradas se conectan a una única capa de neuronas, donde cada nodo está conectado a sus vecinos, y sólo puede haber una neurona activa. La conexión puede ser lineal, cuadrada, hexagonal, irregular, etc. La red detecta grupos similares o clusters en los datos de entrada. Su arquitectura es la siguiente:

Figura 4: Arquitectura de red SOM El entrenamiento consiste en los siguientes pasos: 1-.Se inicializan los pesos de forma aleatoria 2-.Se presenta un vector de entrenamiento 3-.La neurona más cercana al vector es la única que se activa. 4-.Sólo se modifican los pesos de la neurona activa, y de sus vecinas

9

-Lvq El acrónimo viene de Learning Vector Quantization y se trata de un método neural, supervisado, no lineal y no paramétrico. Se podría decir que es un método SOM supervisado para categorizar. Las neuronas se activan por categorias. Se dan dos fases claramente diferenciadas: 1-.En primer lugar se entrena la red SOM no supervisada. Se entrenará por si misma y se agrupará en diversas clases. 2-.Para cada vector de entrada tenemos que tener una codificación de salida y ello implica que se tienen que recalcular y reajustar los pesos. -Fuzzy art Se trata de un método neural no supervisado, no lineal y no paramétrico cuya principal aplicación es la de clasificación. Se trabaja con intervalos de valores comprendidos entre 0 y 1. La neurona ganadora es la que presenta un valor más alto para la función correspondiente. -Fuzzy artmap Es muy similar a la red Fuzzy art pero está supervisada. Al igual que la anterior se trata de un método no lineal, no paramétrico y cuya principal aplicación es la clasificación.

10

1.5.2 Desarrollo del proyecto A continuación se explicará todo el desarrollo del proyecto por etapas. En primer lugar se describirá el código creado para desarrollar 2 nuevos métodos de validación y seguidamente cómo se ha integrado cada uno de ellos en las interficies gráficas correspondientes. Finalmente se explicará la implementación del nuevo método estadístico basado en un algoritmo genético. 1.5.2.1 Método de Validación Por Partes Este método de validación es un método exclusivo para métodos neuronales supervisados. El método Perceptrón multicapa o MLP permite representar mapas no lineales entre un conjunto de variables de entrada y un conjunto de variables de salida. Las redes MLP poseen capas compuestas por neuronas las cuales son las encargadas de procesar la información obtenida. Las neuronas de cada capa, están conectadas con todas las neuronas de la capa posterior y así sucesivamente tal y como se ha podido observar en la Figura 2. El resultado obtenido de una neurona de la capa oculta es igual a una combinación lineal de los datos de entrada más un factor sumatorio llamado bias. El valor final pasa por una función de activación. Entonces, una vez concluido este proceso de entrada y procesado de datos ya se puede iniciar el proceso de apredizaje, el cual consiste en minimizar la función de error en función de los pesos asociados a las neuronas y el bias. Como se ha comentado anteriormente se trata de un método supervisado con lo cual se ha podido implementar e integrar un método de validación para este método neural. La capa de salida está compuesta por unas neuronas cuyo número es generalmente igual al de las posibles clases o agrupaciones en las que podemos clasificar las medidas de entrada. Cabe destacar que si el número de neuronas de la capa de salida fuera inferior al del número de clases en las que vamos a agrupar las medidas, entonces no habría manera de clasificarlas todas puesto que siempre nos faltaría una posible clase en la capa de salida por definir. El método “Por Partes” se encarga precisamente de validar los resultados obtenidos por parte de las neuronas de la capa de salida. Por tanto, antes de realizar la validación se tiene que llevar a cabo todo el proceso de entrenamiento de la red y posteriormente su simulación. Antes de implementar el código se ha diseñado un flujograma donde se pueden distinguir claramente y de un modo generalista las etapas del proceso:

11

M ÉTOD O DE V AL IDA CIÓ N P O R P AR TE S

INPUT % V ECT. DE TES T

CALCULO ITERACIONE S

n=Nº ITE RA CIO NE S

CONTADOR=0

CREA CION DE LA RED

ENTRENAMIENTO DE L A RED

S IMULA CION DE LA RED

CAL CULO DE % DE A CIE RTOS

CONTADOR=n?

CA LCULO DE LA ME DIA DE ACIERTOS

NO

SI

CONTADOR++

12

A continuación se explicará el algoritmo creado de un modo simplificado puesto que en el anexo se adjunta el código de las diversas partes implementadas en toda su totalidad y perfectamente comentado línea por línea. El algoritmo está integrado dentro de una función llamada “Go_sim” que aglutina a los 4 métodos de validación posibles dentro de MLP: -Leave one out -Fold Validation -Por Partes -Bootstrap En este capítulo se explicarán los 2 últimos puesto que son los de nueva creación. En primer lugar ha sido necesario crear varias variables globales. Para crear una variable global sencillamente tenemos que escribir dentro de la función en cuestión, una variable con el texto GLOBAL delante. A continuación se explican brevemente la función de cada una de estas variables: -global RED2 La variable RED2 almacena la red ya inicializada y creada previamente en la función perteneciente al mismo formulario llamada “Go_new”. La creación de la red se realiza a partir de todos los valores que el usuario le va dando progresivamente a los diferentes parámetros de la red. -global rtglobal Esta variable contiene la matriz de targets los cuales provienen de otra función a su vez. Se ha estudiado cómo conseguía, el software ya realizado, el fichero de targets y a partir de ahí se ha realizado un seguimiento para volver a aprovechar la variable que almacenaba la matriz de targets y poder utilizarla de nuevo en este caso. Como se verá posteriormente una vez dentro de la función, existe otra variable que toma el valor que contiene “rtglobal” y esto es debido a que el algoritmo creado trabaja con nombres de variables diferentes. El hecho de que se hayan renombrado algunas variables responde al hecho de que no se quieran mezclar las variables globales con las locales. En este caso dentro del programa:

resultstar=rtglobal;

de modo que posteriormente para tratar la matriz de targets tan sólo haremos referencia a la variable “resultstar”. -global datos Esta variable contiene la matriz de medidas tomadas por los sensores. Al igual que en la variable anterior, se ha realizado un seguimiento de la variable para observar de donde se obtiene y donde es modificada. Cabe destacar que a diferencia de los targets, esta variable puede haber sido modificada y hay que prestarle atención. Esto es debido a que el usuario desde el menú principal puede preprocesar los datos, es decir, centrarlos, autoescalarlos, etc, con lo cual hay cambios de variables por en medio. En “datos” se almacenan los datos preprocesados o los originales, todo depende de lo que haya decidido el usuario

13

anteriormente. En realidad sean unos u otros no afectan a algoritmo de validación puesto que puede procesar ambos tipos. Una vez dentro de la función de simulación, “Go_sim”, el valor de dicha variable será tomado por otra con la que trabajaremos el resto del código hasta realizar toda la validación en su totalidad:

data=datos;

-global NN La variable “NN” contiene el valor del número de sensores que se están considerando. Se utiliza para coger únicamente del fichero de datos las medidas que hay que considerar. Esto es debido a que en las pruebas realizadas con el software, se ha empleado un fichero de datos que junto a las medidas tiene añadidas diversas columnas correspondientes a los targets, y como es evidente tan sólo interesa coger los valores de las medidas y no los targets, es decir, se cogería desde la columna número uno hasta la NN. Sin embargo, en el caso en el que trabajemos con un fichero que únicamente contenga medidas, no pasaría absolutamente nada, puesto que cogeríamos tan sólo las NN primeras columnas ya que no habría más, es decir sería un factor superfluo. A continuación, una vez vistas las variables globales creadas proseguiremos con el algoritmo en sí. Antes de entrar en los 4 métodos de validación, se realizan toda una serie de inicializaciones a todas las variables que van a intervenir en los códigos de los 4 métodos de validación. Dichas variables son de control, es decir lo único que hacen en este caso es comprobar si se ha seleccionado un “radiobutton” o no para saber cual de los 4 métodos ha sido seleccionado para validar. Los detalles sobre la programación relativa a la interficie gráfica se verán más adelante e independientemente a lo que es la programación pura y dura de los métodos de validación. En el caso del método Por Partes, la variable para acceder a él es “porcien”. Este control de acceso se realiza mediante un “if”:

if porcien

Seguidamente el usuario debe de introducir en una “Editbox” el porcentaje de vectores de testeo que desea para entrenar y simular la red posteriormente. Después se calculan las dimensiones tanto de la matriz de datos como la de la matriz de targets para utilizar posteriormente la información:

[nvt c]=size(data) [fclas cclas]=size(resultstar)

En el primer caso “nvt” almacenará el número de filas que posee el fichero data, es decir el número de medidas. Esto es así debido a que el número de vectores de testeo tendrá que ser igual al número de medidas existentes puesto que se han de testear cada una de ellas con su correspondiente vector de testeo. En cuanto a la variable “c” contendrá el número de columnas del fichero de datos, es decir el número de sensores que se están considerando.

14

En el segundo caso “fclas” tomará por valor el número de filas que contiene el fichero de targets, el cual es igual al número de medidas puesto que cada medida será clasificada en una clase y por tanto ambos números tienen que coincidir. La varible “cclas” contiene el número de clases o categorías en las que se podrán clasificar las medidas tratadas. A continuación, a partir del porcentaje de vectores de test introducido por el usuario, calcularemos el número neto de vectores de test e implícitamente el número neto de vectores de entrenamiento:

nvtest=(nvt*pvt)/100 nvtest=round(nvtest) nvtrain=nvt-nvtest

Sabiendo el porcentaje de vectores de test y el número total de vectores o medidas, haciendo una regla de tres podemos calcular el número neto de vectores de test. Por otro lado se utiliza la función “round()” para redondear los valores en caso de que obtengamos un número neto de vectores de test con decimales. Finalmente, también se necesita saber el número neto de vectores de entrenamiento para entrenar la red. Para calcularlo sencillamente se resta el número neto de vectores de test al número total de vectores. El principio de este método se basa en que la porción de vectores de test que se selecciona, sirve para validar a una cantidad igual de vectores originales, mientras que el resto de vectores que no son de testeo se utilizan para entrenar la red. Es decir que si por ejemplo tenemos 100 medidas, y seleccionamos los 10 primeros vectores como vectores de test o sea el 10%, el resto, los otros 90 serán vectores de entrenamiento. Por definición del propio método, para realizar la validación se realizarán tantas iteraciones como grupos de vectores puedan realizarse agrupándolos en grupos con un número de vectores igual al de vectores de test, es decir que en el ejemplo de las 100 medidas, si se tienen 10 vectores de test, se realizarán 10 iteraciones ya que 100/10=10. El proceso sería progresivo, primero se cogerían como vectores de testeo los 10 primeros del 1 al 10, mientras que los vectores situados entre las posiciones 11 al 100 se emplearían para entrenar la red ; después los 10 siguientes, es decir del 11 al 20 serían los de testeo, mientras que los vectores comprendidos entre las posiciones 1 a 10 y 21 a 100 adoptarían el papel de vectores de entrenamiento, y así sucesivamente hasta llegar a la última iteración tomando como vectores de testeo del 91 al 100 y como vectores de entrenamiento del 1 al 90. Dicho proceso está implementado mediante el algoritmo siguiente: i=0; incr=0; ini=1; ini2=0; for i=1:n, if i==2 ini2=1 end vectrain2=data([nvtest+1+incr:nvt],1:NN); if i==1 vectrain1=[0]; vectrain=vectrain2; targetsob2=resultstar([nvtest+1+incr:nvt],:); targetsob=targetsob2; else

15

vectrain1=data([ini2:incr],1:NN); vectrain=[vectrain1; vectrain2]; targetsob2=resultstar([nvtest+1+incr:nvt],:); targetsob1=resultstar([ini2:incr],:); targetsob=[targetsob1; targetsob2]; end vectest=data([ini:nvtest+incr],1:NN); newtarget=resultstar([ini:nvtest+incr],:); incr=incr+nvtest; ini=ini+nvtest; ini2=ini2+nvtest; tvectest=vectest'; tvectrain=vectrain'; tnewtarget=newtarget'; Como se puede observar primero se llevan a cabo las inicializaciones pertinentes, después todo el proceso se incluye dentro de un bucle que generará tantas iteraciones como grupos con un número equivalente al de vectores de testeo podamos hacer con el número total de vectores. Para ir testeando los diversos grupos, se hace uso de variables que se van desplazando a lo largo de toda la matriz de n en n vectores siendo “n” el número neto de vectores de testeo. A continuación se construye la red neuronal. Para ello primero se realizan una serie de comprobaciones para ver si el usuario ha introducido los valores de los parámetros en las “Editbox” correspondientes o bien las deja vacías, en cuyo caso se le dará un valor por defecto al parámetro en cuestión: a=RED2; if d a.trainParam.epochs=e; else a.trainParam.epochs=10; end if f a.trainParam.goal=g; else a.trainParam.goal=0; end a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; Como se puede apreciar en primer lugar se ha creado una variable local “a” la cual toma por valor la varible global que no es mas que la red inicializada con algunos de los parámetros. Obsérvese como se ha hecho uso de campos para configurar los parámetros de entrenamiento de la red. Dentro de la variable “a” está contenido el campo “trainParam” y a su vez dentro de ese último campo están contenidos múltiples parámetros de entrenamiento. Una vez bien definida e inicializada la red ya se puede entrenar mediante:

net = train(a,tvectrain,targetsobt);

16

Como puede apreciarse a la función “train” se le pasan como argumentos la red creada “a”, la matriz de vectores de entrenamiento traspuesta y los vectores de targets sobrantes, es decir el resto de vectores de targets que no corresponden a los de testeo. Seguidamente se simula la red:

Y2 = sim(a,tvectest);

En este caso a la función “sim()” se le pasan como argumentos la red y los vectores de testeo propiamente dichos. Para comprobar el porcentaje de aciertos se ha desarrollado un algoritmo que va comparando los resultados de la simulación, es decir las clases a las que según la red MLP pertenece cada medida con las clases o categorías a las que realmente pertenecen dichas medidas: error=0; errores=0; newY=round(Y2); for q=1:nvtest for j=1:cclas if newY(j,q) == tnewtarget (j,q) else error=1; end end if error==1 errores=errores+1; end error=0; end Aciertos(i)=((nvt-errores)/nvt)*100

Como se puede observar primero se realizan las inicializaciones pertinentes, básicamente para el contaje de errores y el control de bucles y a continuación se redondean los resutados de la simulación para obtener números enteros que se puedan contrastar con los targets originales. Seguidamente se recorren tantas filas como número de vectores de testeo existen, así como también se recorren tantas columnas como clases hayan. Se van comparando entre sí targets originales y resultados obtenidos por la simulación. Si son diferentes se incrementa en 1 el número de errores y así hasta llegar a la última iteración. Finalmente se calcula el número de aciertos mediante la fórmula final. Es evidente que el porcentaje de aciertos será la resta del número total de medidas menos el número de errores, dividido por el número total de medidas y multiplicado por cien. Por último se ha diseñado un pequeño algoritmo para que realice la media de los aciertos de todas las iteraciones que se lleven a cabo: sum=0; k=1; num=max(size(Aciertos)); while k<num+1, sum=sum+Aciertos(k) k=k+1; end mediaciertos=sum/n;

17

Como se puede observar una vez realizadas las inicializaciones necesarias se calcula la dimensión del array “Aciertos” para comprobar cuantas iteraciones se han llevado a cabo y a continuación se van sumando los diferentes valores acumulados en el array, para posteriormente dividirlos entre el número de iteraciones. Finalmente los resultados se muestran por pantalla. En la ventana principal de comandos de Matlab se muestra la media de aciertos que se ha obtenido, y que está contenida en la variable “mediaciertos”. Aparte se va mostrando en ventanas independientes las diferentes iteraciones que se realizan hasta llegar al número de “epochs” deseado:

Figura 5:Ventana de comandos tras ejecución

18

Figura 6: Ejemplo de resultado gráfico tras ejecución. Error v.s. Epochs

En cuanto a la integración del algoritmo en la interficie gráfica se expondrá a continuación lo que se ha realizado. Tan sólo se hará alusión a las funciones y controles empleados puesto que no se trata de un cursillo de programación de GUI. Se partirá con una breve introducción del entorno gráfico para elaborar GUI’s así como de los menús a los que hay que acceder para llegar hasta los métodos de validación integrados. Se parte de un entorno gráfico con pulsadores, editbox, listbox, etc ya realizados:

19

Figura 7: Entorno de trabajo GUI de Matlab

A dichos elementos, llamados controles se les puede asociar funciones que se ejecuten una vez sean seleccionados o clicados. Para acceder al menú MLP partimos del menú principal:

Figura 8: Menú principal del programa

20

Después de cargar el fichero de datos, podemos realizar un preprocesamiento de los mismos con diferentes métodos, ya sea centrado, escalado, etc. Una vez seleccionado el tipo de preprocesamiento se pulsa sobre “Go” y si se desea se pueden ver los datos ploteados por pantalla pulsando sobre “Plot”. A partir de ahí seleccionamos MLP en la listbox de métodos neurales y se nos abrirá otro menú:

: Figura 9: Menú MLP

Como se podrá observar cuando se ejecute se trata de un menú progresivo, es decir que no se pueden elegir las opciones de cualquier lugar del menú si antes no se han seleccionado las anteriores. En el caso de MLP primero el usuario debe elegir o bien los datos preprocesados o bien los datos originales o sin procesar. Seguidamente se tiene que cargar el fichero de targets y a continuación el usuario puede optar por extraer filas o columnas que no le interesen de las matrices correspondientes. Pulsando una vez más sobre “Go” se accede a otra parte del formulario, en la cual se configura la red neural propiamente dicha. En primer lugar se le tiene que dar un nombre a la red. Después el usuario debe indicar cuantas capas tendra teniendo en cuenta que como máximo llegará a 3 capas. Los campos posteriores se rellenan para configurar cada una de las capas introduciendo el número de neuronas que tendrá cada capa así como su función de transferencia. Finalmente se debe indicar el tipo de entrenamiento que se desea para la red y pulsar sobre “Go”. En esta fase ya se accede a los 4 métodos de validación de los que se hablaba anteriormente. Para seleccionar uno de ellos primero se debe introducir un número de “epochs” o iteraciones, al igual que de “goals” o aciertos. Si no se introduce ningún valor,

21

el sistema les impondrá uno por defecto. Finalmente se tienen las 4 opciones posibles correspondientes a los métodos de validación. El control seleccionado para escoger entre las diferentes opciones ha sido el “radiobutton”:

Figura 10: Radiobutton

El “radiobutton” al igual que todos los controles existentes en el entorno GUIDE tiene diversas propiedades relacionadas tanto con su apariencia exterior (colores, título, etc) como con su funcionalidad (botón activado o no en un radio button, opción escogida en un listbox, etc). En concreto en un “radiobutton” se tiene que el Inspector Properties consta de las siguientes propiedades:

Figura 11: Tabla de propiedades de un radiobutton.(Inspector Properties)

Para acceder a este menú lo único que se hace es situar el ratón sobre el “radiobutton” y pulsar el botón derecho. Al realizar ese paso se nos abrirá un pequeño menú para abrir diferentes funciones o propiedades asociadas al control en cuestión, en este caso un “radiobutton”:

22

Figura 12: Opciones existentes en un control Otros tipos que se han utilizado en este proyecto son los siguientes:

Figura 13: Otros tipos de controles

Como se puede apreciar a la izquierda hay una “listbox” que posibilita al usuario mostrar varias opciones posibles. El “pushbutton” es para ejecutar funciones una vez se pulsa sobre él. El “statictext” simplemente es para escribir etiquetas y finalmente el “edit text” o “edit box” sirve para introducir datos por teclado. Todos estos elementos tienen al igual que el “radiobutton” toda una serie de propiedades asociadas, la cuales pueden conocerse si se accede al “Inspector Properties” de cada uno de ellos. Partiendo de las diversas propiedades que posee cada control ya se puede explicar como interaccionan éstas con el usuario. En el caso del método por partes mediante la línea de código contenida en las inicializaciones de la función “Go_sim” se mira si el “radiobutton” de “Por Partes” ha sido seleccionado o no:

porcien=get(handles.porciento,'Value');

como puede apreciarse mediante la función de Matlab “get()”, se pueden conseguir los valores que poseen las distintas propiedades de los diferentes controles. En este caso se mira si el “radiobutton” está seleccionado o no. Dicho valor está almacenado en la propiedad “Value”que contendrá un 1 si está seleccionado y un 0 si no lo está. Este mismo valor es a su vez tomado por la variable “porcien” que se usa como variable de control para poder acceder al código del método Por Partes. Dentro de la función “Go_sim” existen

23

diversos “If” para acceder a uno de los 4 métodos de validación. A partir de “if porcien” empieza el método en cuestión, si la propiedad “Value” del control Radiobutton valía 1 entraremos en el bucle y si no no. Otro elemento de la interficie gráfica que interviene en el proceso es la editbox donde se introduce el porcentaje del número de vectores de testeo:

pvt=str2num(get(handles.epvtest,'String'));

“pvt” es la variable que contiene el porcentaje de vectores de testeo. Como se puede apreciar se vuelve a utilizar la fución “get()” pero esta vez para conseguir una cadena de caracteres, ya que lo introducido por el usuario por teclado es un “string”. El texto “handles.epvtest” es el campo que marca de donde se coge dicho “string”. Una de las propiedades común a todos los controles es el “Tag” donde se indica el nombre con el que será tratado un control en todo el código. En este caso “epvtest” es el “tag” de la “editbox” donde el usuario introducirá el porcentaje de vectores de test. Hay que tener en cuenta que al tratarse de un “string”, el sistema lo identificará y tratará como a tal y no como a un número entero que es lo que se pretende. Para resover esto se utiliza una segunda función para convertir un “string” a un entero: “str2num” que viene de “string to number”. Ahora ya se tiene un entero en la variable “pvt”. Existe otro aspecto muy importante a tener en cuenta en la interficie gráfica esto es la exclusión mutua. Se tiene que considerar que entre los radiobuttons que configuran las diversas opciones debe darse exclusión mutua ya que cuando seleccionemos uno el otro no puede aparecer seleccionado simultaneamente. Para ellos se han tenido que crear dos funciones específicas para los métodos “Por Partes” y “Bootstrap” y modificar las ya existentes para “Leave 1 Out” y “Fold Validation”. Dichas funciones no son mas que “Callbacks” asociadas a los radiobuttons. A continuación se citan y explican cada una de las Callbacks asociadas a cada “radiobutton”: -Leave One Out function Leave1_Callback(h, eventdata, handles, varargin)

a=get(h,'Value');

set(handles.Fold,'Value',0);

set(handles.text52,'Visible','off');

set(handles.Ordre,'Visible','off');

set(handles.Ordre,'Value',1);

set(handles.porciento,'Value',0);

set(handles.bootstrap,'Value',0);

if (a == 1)

set(handles.Go_sim,'Visible','on');

set(handles.Reset_net,'Visible','on');

else

set(h,'Value',0);

set(handles.Go_sim,'Visible','off');

set(handles.Reset_net,'Visible','off');

24

end En primer lugar se puede observar como se consigue la propiedad “Value” una vez más, ya que dentro de la función “Go_sim” se vuelve a adquirir dicho valor. Esto es porque en el momento en el que nos situamos sobre uno de los controles, ya sea “editbox”, “radiobutton” etc, la propiedad “Value” toma por valor el “1”. Las siguientes líneas de código son las que provocan la exclusión mutua. Como se puede observar se resetean a 0 las propiedades “Value” de todos los “radiobuttons” excepto del método en el que se está o se activa, “Leave One Out”. Por otro lado también se hace uso de la propiedad “Visible”, para que no se puedan ver 2 editbox relacionadas con el método “Fold Validation” cuando se elija uno de los otros 3 métodos. Finalmente, las 8 últimas líneas de código son para que una vez seleccionado un método aparezcan visibles las opciones o pulsadores de simulación o reseteo de las “editbox”. -Fold Validation function Fold_Callback(h, eventdata, handles, varargin) a=get(h,'Value'); set(handles.Leave1,'Value',0); set(handles.porciento,'Value',0); set(handles.bootstrap,'Value',0); if (a == 1) set(handles.text52,'Visible','on'); set(handles.Ordre,'Visible','on'); set(handles.Ordre,'String',1); else set(h,'Value',0); set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off'); set(handles.Ordre,'String',1); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end En este caso ocurre a la inversa que en el anterior, en momento que se selecciona el “radiobutton” correspondiente al método “Fold Validation” el resto quedan inhabilitados. En el bucle del final, se mira si el radiobutton actual, el correspondiente al método “Fold Validation” está seleccionado y si es así se activan una serie de editbox y static text. En esas “editbox” el usuario debera introducir los valores de los parámetros pertinentes. De otro modo, si el “radiobutton” no fuera seleccionado se puede ver cómo se vuelven invisibles todas las “editbox” relacionadas con el método en cuestión. -Por Partes function varargout = porciento_Callback(h, eventdata, handles, varargin) a=get(h,'Value'); set(handles.Fold,'Value',0); set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off'); set(handles.bootstrap,'Value',0); set(handles.Leave1,'Value',0); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);

25

set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end Esta función ha sido creada expresamente para el método “Por Partes”. Como se puede apreciar en primer lugar se mira si el “radiobutton” correspondiente al método “Por Partes” ha sido seleccionado mediante la función “get()”. Seguidamente se consigue la exclusión mutua del resto de “radiobuttons” mediante la fijación de la propiedad “Value” a “0”. De un modo similar fijamos la propiedad “Visible” del control en “off” de las editbox correspondientes al método “Fold Validation”. Finalmente el bucle condicional una vez más hace aparecer o desaparecer los pulsadores correspondientes a la simulación y el reset de las “editbox”, así como también pone a “0” el valor de la propiedad del “radiobutton” correspondiente al método “Por Partes”. -Bootstrap function varargout = bootstrap_Callback(h, eventdata, handles, varargin) a=get(h,'Value'); set(handles.Leave1,'Value',0); set(handles.Fold,'Value',0); set(handles.porciento,'Value',0); set(handles.conjboot,'String',1); set(handles.pvectrain,'String',1); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end Al igual que la anterior esta función también ha sido creada para el método “Bootstrap”. De la misma manera que en los anteriores casos, primero se mira si el “radiobutton” en cuestión ha sido seleccionado, después se hacen visibles o invisibles los controles pertinentes y finalmente se hacen visibles o no los pulsadores de simulación y reset dependiendo de si seleccionamos el “radiobutton” o no. Otro aspecto considerado a la hora de programar la interficie gráfica ha sido el hecho de que el menú es progresivo, es decir que las editbox, listbox y otros tipos de controles que tienen que ir siendo rellenadas por el usuario vayan apareciendo conforme se van introduciendo los valores en las casillas. Para conseguir esto en la última fase del formulario, se ha implementado el siguiente código: set(handles.Epoch,'Visible','on'); set(handles.Epoch,'Value',0); set(handles.Goal,'Visible','on'); set(handles.Goal,'Value',0); set(handles.Fold,'Visible','on'); set(handles.Fold,'Value',0); set(handles.Leave1,'Visible','on'); set(handles.Leave1,'Value',0); set(handles.porciento,'Visible','on'); set(handles.porciento,'Value',0); set(handles.bootstrap,'Visible','on'); set(handles.bootstrap,'Value',0); set(handles.porciento,'Visible','on'); set(handles.bootstrap,'Visible','on'); set(handles.text53,'Visible','on'); set(handles.epvtest,'Visible','on');

26

set(handles.text54,'Visible','on'); set(handles.conjboot,'Visible','on'); set(handles.text55,'Visible','on'); set(handles.pvectrain,'Visible','on'); Como se puede observar se hace uso de la función de “set()” para cambiar la propiedad “Visible” de los diferentes controles. El método “Por Partes” integrado en el menú LVQ es exactamente igual, sólo que cambian algunos nombres de variables. El método LVQ evidentemente es diferente al MLP y para integrar el método por partes en él se ha tenido que analizar paso por paso las funciones ya implementadas y las variables existentes. Además al tratarse de un método un tanto diferente también varía el formulario principal:

Figura 14: Menú LVQ

El LVQ o Learning Vector Quantization es un método de entrenamiento destinado a capas competitivas que como ya se ha dicho antes consiste en un método supervisado. Se podría afirmar que se trata de una versión de la SOM pero supervisada. Aunque las clases que encuentra la capa competitiva tan sólo dependen de la distancia entre los vectores de entrada. En el caso en el que 2 vectores de entrada sean muy parecidos LVQ no necesariamente los distinguirá puesto que no existe un mecanismo para distinguir una medida de otra. Por otro lado el método tiene una manera de clasificar vectores de entrada según los targets asignados por el usuario. En resumen se trata de una técnica que consta de 2 capas, la primera es la competitiva y la segunda es lineal. La primera aprende a clasificar los vectores de entrada mientras que la

27

segunda transforma las clases determinadas en la primera a las clases asignadas por el usuario. Ambas capas tienen una neurona por clase, lo cual implica que el número de neuronas de la primera capa será superior o como mínimo igual al número de neuronas de la segunda.

28

1.5.2.2 Método de Validación Bootstrap El método de validación “Bootstrap” consta de 3 fases bien diferenciadas: 1.-Generar un conjunto de entrenamiento 2.-Entrenar la red 3.-Validar o simular mediante el conjunto de testeo Todas estas fases están comprendidas en un bucle que realizará tantas iteraciones como conjuntos “bootstrap” haya fijado el usuario desde el principio. Para poder distinguir de una manera clara y muy generalista el proceso llevado a cabo en el método “Bootstrap” se muestra a continuación su diagrama de flujo:

29

M É TO DO DE V ALIDA CIÓN B OO TS TR AP

INPUT Nº CONJUNTOS BOOTSTRAP

INPUT % VECT. DE ENTRENAMIENTO

GENERACIÓN ALEA TORIA DE V ECT. DE ENTRE NA M.

GENERACIÓN DE VE CT DE TE ST

CONTADOR=0

ENTRENAMIENTO DE LA RE D

SIMUL ACION DE LA RED

CA LCULO DE % DE A CIE RTOS

CONTADOR=Nº CONJUNTOS BOOTSTRAP ?

CALCUL O DE LA ME DIA DE ACIERTOS

CRE ACIÓN DE LA RED

CONTADOR++

NO

S I

30

Para explicar el método “Bootstrap” es indiferente que se explique implementado sobre MLP o sobre LVQ puesto que el funcionamiento es exactamente el mismo y tan sólo cambian algunas variables empleadas. Al igual que en el método anterior, en este también se hace uso de algunas variables globales: -global RED2 -global rtglobal -global datos -global NN Todas ellas realizan exactamente la misma función que realizaban en método “Por Partes”, “RED2” contiene la red, “NN” es el número total de sensores que se tienen en cuenta y finalmente “rtglobal” y “datos” son variables globales auxiliares que contienen los valores de los targets empleados y las medidas respectivamente. De estas 2 últimas se realiza un cambio de variable al igual que en el método anterior para poder trabajar dentro del bucle con otros nombres de variable. Seguidamente, se describirá el algoritmo implementado en este caso. Como en el método anterior, en el “Bootstrap” también se realizan una serie de inicializaciones relacionadas directamente con la interficie gráfica y las funciones de entrada y salida de datos por teclado, así como las activaciones de pulsadores, etc mediante el ratón. Para entrar en el bucle se comprueba el valor binario de una variable:

if boot

Luego mediante variables de entrada y salida de datos se obtiene el número de conjuntos “bootstrap” que el usuario quiere que se creen y a continuación se le pide el porcentaje de vectores de entrenamiento que quiere que haya en cada iteración. Estas líneas de código forman parte de la interficie gráfica y serán explicadas más adelante en la parte que se refiere a la integración del algoritmo “Bootstrap” en el formulario gráfico. A continuación, mediante las líneas de código siguientes adquirimos los datos sobre las dimensiones tanto de la matriz de datos como de la de targets:

[nvt c]=size(data) [fclas cclas]=size(resultstar)

Ahora se calcula el número neto de vectores de entrenamiento a partir del porcentaje, y después, por si ha dado una cifra con decimales, se redondea el resultado obtenido mediante la función “round()”:

nvent=(pve*nvt)/100

nvent=round(nvent)

Mediante la variable “cb” inicializo el contador del número de conjuntos “bootstrap”, es decir del número de iteraciones que se llevarán a cabo:

cb=0

31

Seguidamente mediante las líneas de código:

while cb<numboot,

cb=cb+1; se controla el número de conjuntos “bootstrap” que se llevan realizados hasta el momento, y una vez dentro del bucle “while” incremento el contador para llevar la cuenta. A partir del siguiente código se generan aleatoriamente el número o índice de las filas de vectores de entrenamiento para posteriormente formar una matriz compuesta por vectores de entrenamiento. La dimensión de dicha matriz, llamada “ale”, será de 1 x Número de vectores de entrenamiento. Dichos vectores se seleccionan al azar del conjunto de vectores totales:

ale=rand(1,nvent)

La función “rand()” produce en este caso un número igual al valor de la variable “nvent” de índices de vectores o números de fila de una matriz que posteriormente serán seleccionadas. Los números generados por esta función van de “0” a “1”, con lo cual se deberán normalizar dichos números multiplicándolos por el número máximo de vectores de los que se dispone. Con esta operación ya se obtienen números entre “0” y “nvt” pero como es evidente pueden tener decimales. Para solucionar esto último se vuelve a redondear mediante la función “round()”:

ale=round(nvt*ale);

Luego mediante la función “sort()” se ordenan los valores de los índices obtenidos de menor a mayor para facilitar su tratamiento en el subalgoritmo posterior:

ale=sort(ale); Seguidamente como para Matlab no existe la posición número cero en un array o vector, sustituimos todos los índices que nos hayan dado 0 por 1, puesto que el 1 si que lo reconoce como primera posición: for t=1:nvent if ale(t)==0 ale(t)=1; end end k=0; Ahora ya se puede formar una matriz de vectores de entrenamiento válida. El nombre de la matriz de entrenamiento es “matent”:

matent=data([ale],1:NN) Se puede apreciar como se coge cada índice de fila mediante la variable “ale” y después todas las columnas hasta llegar al número de sensores tenidos en cuenta.

32

Seguidamente se tiene que crear la matriz de vectores de testeo o validación. Dicha matriz estará formada por todos los vectores que no se encuentran en la matriz de vectores de entrenamiento. Para detectar los que los que no están en la matriz de vectores de entrenamiento, se ha desarrollado el siguiente código: if ale(1)>1 for k=1:ale(1)-1 cont(k)=k; end end for i=2:nvent q=ale(i)-ale(i-1) if q>1 for j=1:q-1 k=k+1; cont(k)=ale(i-1)+j; end end end Como se puede observar, se van cogiendo los índices contenidos en el array “ale” y se va mirando si dichos índices se encuentran entre los de la matriz de vectores de entrenamiento. Por tanto la matriz de vectores de testeo será:

matval=data([cont],1:NN) y del mismo modo se deben obtener las matrices de targets tanto para los vectores de testeo como para los vectores de entrenamiento. Como se conocen las dimensiones de ambas matrices tan sólo se debe hacer:

matargv=resultstar([cont],:) matarge=resultstar([ale],:)

La variable “matargv” contiene la matriz de targets de validación y la “matarge” la matriz de vectores de entrenamiento. Ahora se tiene que entrenar y simular la red tantas veces como conjuntos “Bootstrap” haya indicado el usuario, pero para ello se han hecho una serie de cambios a algunas variables para trabajar con mayor comodidad:

tmatval=matval'; tmatent=matent'; tmatargv=matargv'; tmatarge=matarge';

[res numtest]=size(tmatargv);

Además se adquiere la dimensión de la matriz de vectores de validación para emplearla posteriormente en un algoritmo diseñado para el control de aciertos. A continuación se configuran los valores de los parámentros pertenecientes a la red: if d RED2.trainParam.epochs=e;

33

else RED2.trainParam.epochs=10; end if f RED2.trainParam.goal=g; else RED2.trainParam.goal=0; end RED2.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; RED2.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; RED2.trainParam.max_perf_inc=1.04; RED2.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; RED2.trainParam.show=25;a.trainParam.time=inf; Finalmente se pasa a entrenar y simular la red:

net = train(RED2,tmatent,tmatarge); Y2 = sim(RED2,tmatval);

Después de la simulación hay que realizar la comprobación de aciertos conseguidos. Esto se hace mediante el código siguiente: error=0; errores=0; [valor posicio]=max(Y2); for indx=1:numtest newY(posicio(indx),indx)=1; end [res1 res2]=size(newY); if res1<res newY(res,1)=0; end for qu=1:numtest for ju=1:cclas if newY(ju,qu) == tmatargv (ju,qu) else error=1; end end if error==1 errores=errores+1 end error=0; end Aciertos(cb)=((numtest-errores)/numtest)*100 end

Finalmente, al igual que en el método “Por partes” se realiza la media de los resultados de las diversas iteraciones: sum=0; w=1; num=max(size(Aciertos)); while w<num+1, sum=sum+Aciertos(w) w=w+1; end mediaciertos=sum/numboot; mediaciertos

34

A continuación se explica la integración del método “Bootstrap” en la interficie gráfica. En primer lugar cabe destacar que se ha realizado un código para que los menús vayan apareciendo de un modo progresivo en el formulario. Dicho código ha sido ya explicado anteriormente para el método “Bootstrap”. Del mismo modo se ha creado otro código relativo a la interficie gráfica para conseguir la exclusión mutua entre los “radiobuttons” pertenecientes a los 4 métodos de validación. La parte relativa al método “Bootstrap” ya ha sido explicada. Para acceder al método de validación “Bootstrap” se hará una vez más desde el menú principal. Se carga el fichero de datos se preprocesan las medidas si el usuario lo cree conveniente y finalmente se elige de la listbox uno de los métodos neuronales que contiene el método “Bootstrap” de validación. En todos ellos el sistema de integración es el mismo y tan sólo cambia como mucho el nombre que se le da a las diferentes variables que intervienen. Primero de todo se comprueba si el radiobutton correspondiente al método “Bootstrap2 ha sido selecionado la línea de código siguiente:

boot=get(handles.bootstrap,'Value');

A continuación si efectivamente ha sido seleccionado se entrará en el bucle. Una vez dentro entran en juego las funciones de entrada y salida por teclado para que el usuario introduzca en primer lugar el número de conjuntos “bootstrap” que desea y en segundo lugar el porcentaje de vectores de entrenamiento:

numboot=str2num(get(handles.conjboot,'String'))

pve=str2num(get(handles.pvectrain,'String'))

Una vez más se coge la cadena de caracteres introducida por el usuario, que consistirá en una cadena de números, y seguidamente mediante la función “str2num()” se convierte la cadena a un número entero tratable por el resto del algoritmo.

35

1.5.2.3 Algoritmo Genético

Como introducción se podría decir que los algoritmos genéticos están basados en el proceso genético de los organismos vivos. A lo largo de las generaciones las poblaciones evolucionan en la naturaleza según los principios de la selección natural y la supervivencia de los más fuertes postulados por Darwin.

Los individuos que tienen más éxito en sobrevivir y atraer a compañeros/as de su misma especie, tienen más probabilidades de generar un mayor número de descendientes. Por el contrario los individuos poco dotados producirán un menor número de descendientes y a la larga pueden llegar a desaparecer. Esto significa que los genes de los individuos mejor adaptados se propagarán en sucesivas generaciones hacia un número de individuos ascendente. Por imitación de este proceso los algoritmos genéticos son capaces de ir creando soluciones a problemas de la vida real. La evolución de dichas soluciones hacia valores óptimos del problema dependerá en gran medida de una adecuada codificación de las mismas. El algoritmo genético es un procedimiento de resolución de problemas que imita a los métodos de evolución genética de los seres vivos para solucionar problemas de investigación (en los cuales el proceso analiza las posibles soluciones de un problema) y optimización (la cual encuentra el mejor resultado para un problema específico. Las características de los algoritmos genéticos son las siguientes: -Son algoritmos estocásticos. Dos ejecuciones diferentes pueden dar como resultado soluciones diferentes. Esto es útil por el hecho de que hay gran cantidad de resultados que corresponden a soluciones válidas. -En los algoritmos genéticos, excepto poblaciones iniciales muy degeneradas, la convergencia del algoritmo es poco sensible a la población inicial si ésta es escogida de forma aleatoria y es lo suficientemente grande. -Por su grado de penetración casi nulo, la curva de convergencia asociada al algoritmo presenta una convergencia excepcionalmente rápida al principio, que casi se bloquea de repente. Esto es debido a que el algoritmo genético es excelente descartando subespacios realmente malos. Cada cierto tiempo la población vuelve a dar un salto evolutivo y se produce un incremento en la velocidad de convergencia. La razón de ello es que algunas veces aparece una mutación altamente beneficiosa que propaga algún conjunto de cromosomas excepcional al resto de la población. -La optimización está en función de la representación de los datos. Éste es el concepto clave dentro de los algoritmos genéticos ya que una buena codificación puede hacer la programación y la resolución muy sencilla. -Es una investigación paramétrica robusta. Esto quiere decir que tenemos que elegir muy mal los parámetros del algoritmo para que no llegue a converger. Con los parámetros razonables convergerá, mejor o peor, en una solución razonablemente buena si la representación es la adecuada. Esto es muy importante para la naturaleza de nuestra investigación. Para crear un algoritmo genético se tienen que seguir ciertos pasos. En primer lugar se genera aleatoriamente la población inicial, que estará constituida por un conjunto de cromosomas o cadena de caracteres, que representan las soluciones posibles del problema. A cada uno de los cromosomas de esta población se le aplicará la función de aptitud con el

36

fin de saber cuan buena es la solución que está codificando. Sabiendo la aptitud de cada cromosoma se procede a la selección de los que se cruzarán en la siguiente generación. La codificación más común de las respuestas se realiza mediante cadenas binarias, aunque también se han utilizado números reales y letras. El sistema más adecuado es el primero puesto que resulta más sencillo de implementar. La función de aptitud a la que antes hemos hecho referencia es la base para determinar qué soluciones tienen mayor o menor porbabilidad de sobrevivir. Dado un cromosoma particular, la función de aptitud le asigna un número real que supuestamente refleja el nivel de adaptación al problema del individuo representado por este cromosoma. Esta función de aptitud, llamada también función de adaptación, tiene que ser diseñada de manera específica para cada problema, o como en el caso en cuestión, sustituida para obtener el resultado utilizando otro método. En cuanto al tamaño de la población es interesante que no sea muy pequeña ya que en ese caso se corre el riesgo de no cubrir adecuadamente el espacio de investigación, mientras que si la población es realmente elevada podemos llegar a tener un problema con el tiempo de ejecución del programa. En lo que hace referencia a la selección de individuos, existen una serie de técnicas de selección:

-Selección directa: Selecciona elementos de acuerdo con un criterio objetivo, como por ejemplo: los “x” mejores, los “x” peores, etc.

-Selección aleatoria: Puede ser realizada por selección equiprobable o por selección estocástica: a).Selección equiprobable: Todos tienen la misma probabilidad de ser escogidos. b).Selección estocástica: La probabilidad de que un individuo sea escogido depende de una heurística. Las técnicas de cruce permiten la generación de nuevos individuos cogiendo características de sus padres. A continuación se explican algunas técnicas de cruce básicas: -Cruce Básico: Se selecciona un punto al azar de la cadena o cromosoma. La parte anterior es copiada del genoma del padre y la posterior del de la madre. -Cruce Multipunto: Igual que el cruce básico pero con la pequeña diferencia de que establece otro punto de cruce. -Cruce Segmentado: Existe la probabilidad de que un cromosoma sea un punto de cruce. A medida que se va formando la nueva cadena del descendente, se verifica si ahí se producirá un cruce para cada gene. -Cruce Uniforme: Cada gene de la descendencia se crea copiando el gene correspondiente de uno de los padres, escogido de acuerdo con una máscara de cruce. Cuando exista en uno la máscara de cruce, el gene se copiará del primer padre, y si en cambio es un cero el gene es copiado del segundo padre. Las técnicas de mutación permiten introducir nueva información no presente en la población y que tenga una baja probabilidad de ser utilizada. Algunas técnicas de mutación son las siguientes:

37

-Mutación de bit: Existe una única probabilidad de que se produzca una mutación de algún bit. Si se produce el algoritmo selecciona aleatoriamente un bit y lo invierte. -Mutación Multibit: Cada bit tiene una probabilidad de mutarse o no. Dicha probabilidad es calculada en cada pasada del operador de mutación multibit. -Mutación de intercambio: Existe la probabilidad de que se produzca una mutación. Si se produce toma 2 bits aleatoriamente y los intercambia. En cuanto a la implementación e integración en la interficie gráfica el formulario del menú principal de este método tiene la siguiente forma:

Figura 15: Menú del Algoritmo Genético

38

Como se puede apreciar se trata de un formulario con etiquetas de texto estático, un pulsadores, radiobuttons y editbox. El sistema de introducción de datos al igual que en los casos anteriores también es progresivo. Primero se pulsa el pulsador correspondiente al fichero de targets para introducir este último. Una vez pulsado aparece un “browse” o menú desplegable donde se buscará el archivo a partir de carpetas y subcarpetas. Una vez seleccionado el archivo, en el “statictext de la derecha del pulsador queda definido el “path” o ruta del archivo. A continuación el usuario debe elegir entre utilizar las variables originales o las preprocesadas mediante la selección de un radiobutton u otro. Después se tienen que ir rellenando las editbox dando valores a los parámetros pertinentes y teniendo en cuenta de que dichos valores en muchos casos están limitados entre 2 cifras. Finalmente tan sólo hay que apretar sobre el pulsador “Executa”.

Para acceder al menú del algoritmo genético se ha tenido que modificar el formulario principal. Para ello se ha modificado la listbox donde están contenidos los métodos estadísticos en el “Inspector Properties” añadiendo una opción más correspondiente al algoritmo genético y al que se le ha llamado “Gaselctr”. Después de dicha modificación el formulario ha quedado de la siguiente forma:

Figura 16: Situación de la nueva opción Gaselctr en el menu principal

Como puede observarse ahora ya consta la opción “Gaselctr” para poder ser elegida en la listbox de la izquierda. Naturalmente este cambio viene acompañado de una ligera modificación en el código asociado a la listbox, puesto que se ha añadido otra opción: -function Go_est_Callback(h, eventdata, handles, varargin) global STATUS; met=get(handles.Pre,'Value'); %de aki saca el el metodo elegido a=exist('c:\matlabr12\work\dataini.mat'); %aki la a y la b obtendran el valor 1 si existe el fichero b=exist('c:\matlabr12\work\datapre.mat'); %y si no obtendran el valor 0

39

if a %mira si existe el fichero de datos orig. load('c:\matlabr12\work\dataini.mat'); end if b %mira si se ha creado el fich de datos preproces. load('c:\matlabr12\work\datapre.mat'); end if (b & a & (resultspre ~= []) & (resultsini ~= []) & (nompre == nomini) & (metpre == met)) %si existen los 2 archivos es q se han %preprocesado los datos (resultspre diferente de cero implica q existe) %Les dades processades provenen de l'arxiu original STATUS=2; %si se han preprocesado los datos STATUS vale 2 elseif (a & (resultsini ~= [])) %Les dades processades no son de l'arxiu original o no existeixen %(es vol treballar amb les originals) STATUS=1;resultspre=[];nompre=nomini; save('c:\matlabr12\work\datapre.mat','resultspre','nompre'); else STATUS=0; end if (STATUS ~= 0) met=get(handles.Est,'Value'); if (met == 2) menu_pca; end if (met == 3) menu_cluster; end if (met == 4) menu_pcr; end if (met == 5) menu_pls; end if (met == 6) menu_dfa; end if (met == 7) gaselnew; end else nadena=0; end Esta es la función que se ejecuta en momento que se pulsa sobre el pulsador “Go” de la listbox correspondiente a los métodos estadísticos. La variable “STATUS” sirve para saber si se han escogido los datos originales o preprocesados. Una vez conocido esto lo que corresponde es elegir un método de una de las 2 listbox. En este caso se trata de la listbox de los métodos estadísticos. Como se puede apreciar la variable “met” toma como valor el contenido en la propiedad “Value” de la listbox. Dicho valor corresponde al número o índice donde se encuentra cada uno de los métodos estadísticos ordenados. A continuación se mira a qué método corresponde el seleccionado mediante sentencias condicionales “if”, y si coincide el índice con el valor contenido en “met” se ejecuta la función que hay dentro del “if” que no es más el menú de cada uno de los métodos. En lo que se refiere al código implementado bajo la interficie, se trata en su mayoria de funciones de entrada y salida por teclado, puesto que la función que finalmente calcula el resultado ya venía implementada en una de las toolbox de Matlab. Después de haberse explicado el manejo desde el punto de vista del usuario, se pasará a analizar cada una de las funciones creadas:

40

-function varargout = dator_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.dator. global rtglobal; %declaramos estas var globales para poder usarlas global resultsini; global x; global y; load('c:\matlabr12\work\dataini.mat'); set(handles.datpre,'Value',0); x=resultsini; y=rtglobal; La función “dator” es la función asociada al radiobutton de los datos originales. Si se selecciona dicho radiobutton entonces se ejecuta la función actual. Como se puede observar en primer lugar se declaran una serie de variables globales para que los datos almacenados en ellas puedan ser tratados en funciones posteriores. En la variable “rtglobal” quedarán almacenados los targets y en “resultsini” los datos sin preprocesar. A continuación mediante la función “load()” cargamos el fichero donde se han salvado en una función perteneciente a otro menú los datos originales. Seguidamente se lleva a cabo la exclusión mutua mediante la puesta a “0” de la propiedad “Value” del radiobutton correspondiente a los datos preprocesados. Finalmente las variables “x” e “y” cogen en este caso sus valores respectivos puesto que intervienen directamente en la función final. -function varargout = datpre_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.datpre. global rtglobal; %declaramos estas var globales para poder usarlas global resultspre; global x; global y; load('c:\matlabr12\work\datapre.mat','resultspre','nompre','metpre','valorpre','stdxpre'); set(handles.dator,'Value',0); x=resultspre; y=rtglobal; Este caso es similar al anterior, sólo que en este caso los ficheros que se cargan mediante la función “load()” son aquellos donde han sido almacenados los datos previamente preprocesados. Luego mediante la función “set()” se pone a cero la propiedad “Value” del radiobutton correspondiente a los datos originales para conseguir la exclusión mutua y finalmente las variables “x” e “y” cogen sus valores correspondientes. -function varargout = cargatar_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.cargatar. global rtglobal; [filename,pathname]=uigetfile('*.*','Carregar fitxer targets'); nomtar=[pathname,filename]; %se coge la ruta de donde esta el fichero y su nombre

41

resultstar=load(nomtar); %una var. pilla los datos de antes rtglobal=resultstar; set(handles.rutar,'String',nomtar); En este caso primero se vuelve a declarar la variable global correspondiente a los targets, “rtglobal” y después mediante la función “uigetfile()” se desplegará un fichero donde apareceran las múltiples carpetas de las unidades o discos en activo del ordenador, para que se seleccione el archivo de targets de alguna de ellas. Luego mediante la variable “nomtar” se consigue la ruta del archivo y su nombre, a continuación se carga dicho archivo mediante la función “load()” en la variable “resulstar” que es la que se emplea para almacenar los targets. Finalmente para que la ruta o “path” donde se encuentra el fichero de targets sea visible en un “statictext” variamos mediante la función “set()” la propiedad “String” del editbox cuyo “Tag” o etiqueta es “rutar”. A continuación se citan todas las funciones relativas a la entrada de los parámetros de la función en cuestión: -function varargout = np_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.np. global np; np=str2num(get(handles.np,'String')); -function varargout = edit3_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit3. global mg; mg=str2num(get(handles.mg,'String')); -function varargout = edit4_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit4. global mt; mt=str2num(get(handles.mt,'String')); -function varargout = edit5_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit5. global wn; wn=str2num(get(handles.wn,'String')); -function varargout = edit6_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit6. global cn; cn=str2num(get(handles.cn,'String')); -function varargout = edit7_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit7. global bf; bf=str2num(get(handles.bf,'String')); -function varargout = edit8_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit8.

42

global cr; cr=str2num(get(handles.cr,'String')); -function varargout = edit9_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit9. global ml; ml=str2num(get(handles.ml,'String')); -function varargout = edit10_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit10. global cv; cv=str2num(get(handles.cv,'String')); -function varargout = edit11_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit11. global sp; sp=str2num(get(handles.sp,'String')); -function varargout = edit12_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit12. global it; it=str2num(get(handles.it,'String')); Como se puede apreciar en todas estas funciones lo primero que se hace es declarar como global la variable o parámetro que va a recibir un valor por parte del usuario por teclado. Esto es porque existe una función, la función final, que como se verá a continuación tendrá que utilizar dichas variables para proporcionar un resultado. Cabe destacar que una vez más, mediante la función “get()” se obtiene la cadena de caracteres que introduce en la editbox correspondiente el usuario y simultaneamente se convierte el “string” a número entero mediante la función “str2num()”. -function varargout = ejecuta_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.ejecuta. global x; global y; global np; global mg; global mt; global wn; global cn; global bf; global cr; global ml; global cv; global sp; global it; [fit,pop] = gaselctr(x,y,np,mg,mt,wn,cn,bf,cr,ml,cv,sp,it); fit pop

43

Por último se presenta la función encargada de calcular y mostrar el resultado final. Se puede apreciar como en primer lugar se citan todas las variables nombradas antes como globales y que van a intervenir en el cálculo. Después mediante la función “gaselctr()”, ya incluida en la toolbox, se realizan una serie de cálculos y se muestran por pantalla las gráficas resultantes. Finalmente se muestran en la pantalla de comandos las variables resultantes “fit” y “pop”. Además de los resultados númericos presentados en la ventana de comandos de Matlab, también se abre una ventana con 4 gráficos. Como ejemplo se han introducido los datos que se ven en la figura:

Figura 17: Ejemplo de Algoritmo Genético

Y se han obtenido los siguiente resultados:

45

Figura 18: Resultado obtenido tras ejecutar el ejemplo anterior

Y en la ventana de comandos, como resultados numéricos se ha obtenido: The best fitness is 0.0830133 The average fitness is 0.0852838 fit = Columns 1 through 4 0.0830 0.0831 0.0838 0.0844 Column 5 0.0921 pop = Columns 1 through 6 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 1 0 1 0 0 0 1 0

46

Columns 7 through 10 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 1 1 0 0 1 El algoritmo ha convergido en la séptima generación: en la generación 7 el 80% de los cromosomas son idénticos).

De los resultados anteriores se deduce que seleccionando las variables 5, 7 y 10 (sólo 3 variables de las 10 disponibles inicialmente) es suficiente para obtener un buen modelo PLS entre los datos y los targets.

47

2 Conclusiones

El proyecto llevado a cabo es un sólido punto de apoyo para la docencia de la asignatura de Sistemas de Percepción de 5º curso de Ingeniería en Automática y Electrónica Industrial. La interficie gráfica es un entorno que resulta mucho más amigable al alumno en contrapartida a que él mismo tenga que desarrollar el software, puesto que no se trata de hacer un cursillo de programación en Matlab y menos de su interficie gráfica si no de aprender el funcionamiento y el fundamento de los sistemas de reconocimiento de patrones. Se trata de un sistema muy práctico y muy específico, ya que el usuario lo único que debe hacer es escoger las diversas opciones de los diferenes menús ya implementados e introducir los valores de los múltiples parámetros de cada método. En concreto, los nuevos métodos creados e implementados en este proyecto hacen de la interficie una herramienta muy completa para el estudio y simulación de los métodos de reconocimiento de patrones e incluso muy a tener en cuenta para cursos de doctorado que versen sobre el tema. Se puede decir que se han implementado ya todos los métodos de validación más habituales para métodos de reconocimiento de patrones supervisados. Además la creación del método del algoritmo genético abre una amplia ventana de posiblidades dentro de los métodos estadísticos. En lo que hace referencia al plano personal la programación en Matlab es realmente interesante. Es muy parecido a cualquier lenguaje de alto nivel típico, como por ejemplo el “C”, aunque bastante más limitado. Su potencia y uno de sus principales encantos reside básicamente en los múltiples “Toolboxes” existentes que cubren multitud de areas tanto en ingeniería como en física aplicada. En cuanto a la programación de la interficie gráfica se trata de algo francamente fácil y muy intuitivo. Existe toda una gama de controladores (pulsadores, “editbox”, “listbox”,etc) ya creados, y cada uno de los cuales posee una serie de propiedades alterables en función de las necesidades del programador. Para que dichos controladores interactuen con el usuario llevan asociados a ellos una serie de funciones llamadas “callbacks” las cuales son programables en el lenguaje propio de Matlab. En general la realización del proyecto ha sido muy satisfactoria y muy interesante puesto que es un tema muy actual y sobre el que todavía se sigue investigando. Por otro lado las aplicaciones de los métodos de reconocimiento de patrones están íntimamente ligadas a temas de vanguardia como robótica e inteligencia artificial, que a medio plazo tendrán sin duda una gran repercusión en la sociedad. Hasta ahora los sistemas controlaban situaciones más o menos simples mediante una cantidad limitada y específica de sensores, como determinadas medidas, proximidad de piezas. Ahora se aspira a intentar tratar flujos de información muy densa, como por ejemplo la información que genera el aroma de una fruta o de un gas compuesto de diversos productos químicos. Conforme se desarrolle esta tecnología su uso se generalizará en muchos ámbitos de la vida diaria.

48

3 Pliego de Condiciones

3.1. GENERALIDADES 3.1.1. CONDICIONES GENERALES. · El presente pliego de condiciones tiene como objetivo definir a la empresa

programadora el alcance del trabajo y la ejecución cualitativa del mismo. · El trabajo informática consistirá en la creación del programa y todas las pruebas

oportunas para asegurar la fiabilidad del mismo. · El alcance del trabajo de las empresa Programadora incluye el diseño y preparación

de todo el material necesario para la adquisición e instalación del programa. 3.1.2. REGLAMENTOS Y NORMAS. Todas las unidades del programa se ejecutarán cumpliendo las prescripciones

indicadas en los Reglamentos y Normas Técnicas de obligado cumplimiento para este tipo de instalaciones, tanto de ámbito nacional, autonómico como municipal, así como, todas las otras que se establezcan en la Memoria Descriptiva.

Se adaptarán además, a las presentes condiciones particulares que complementarán

las indicadas por los Reglamentos y Normas citadas. 3.1.3. EJECUCION DEL PROGRAMA. 3.1.3.1. COMIENZO: La Empresa Programadora comenzará a crear el programa en el termino que figura

en el contrato establecido con la Empresa Usuaria, o en su defecto a los quince días de la adjudicación definitiva o la firma del contrato.

la Empresa Programadora está obligada a notificar por escrito o personalmente en

forma directa a la Empresa Usuaria la fecha de comienzo de la realización del Programa.

3.1.3.2. PLAZO DE EJECUCIÓN: El programa se ejecutará en el terminio que se estipule en el contrato suscrito con la Empresa Usuaria o en su defecto en el que figure en las condiciones de este pliego. Cuando la Empresa Programadora, de acuerdo, con alguno de los extremos

contenidos en el presente Pliego de Condiciones, o bien en el contrato establecido con la Empresa Usuaria, solicite una inspección para poder realizar algún trabajo ulterior que esté condicionado por la misma, vendrá obligada a tener preparada para dicha inspección, una cantidad de obra que corresponda a un ritmo normal de trabajo.

49

Cuando el ritmo de trabajo establecido por el Contratista, no sea normal, o bien a petición de una de las partes, se podrá convenir una programación de inspecciones obligatorias de acuerdo con el plan de obra.

3.1.4. INTERPRETACIÓN Y DESARROLLO DEL PROGRAMA. La interpretación técnica del Programa, corresponde al Técnico Director. La

Empresa Programadora está obligada a someter a éste a cualquier duda, aclaración o contradicción que surja durante la ejecución del Programa por causa de una mala interpretación, o circunstancias ajenas, siempre con la suficiente antelación en función de la importancia del asunto.

La Empresa Programadora se hace responsable de cualquier error de la ejecución

motivada por la omisión de ésta obligación y consecuentemente deberá rehacer a su costa los trabajos que correspondan a la correcta interpretación del Proyecto.

La Empresa Programadora está obligada realizar todo cuanto se necesario para la

buena ejecución del Programa, aún cuando no se halle explícitamente expresado en el Pliego de Condiciones o en los documentos del Proyecto.

La Empresa Programadora notificará por escrito o personalmente en forma directa al

Técnico Director y con suficiente antelación las fechas en que quedarán preparadas para inspección, cada una de las partes del Programa para las cuales se ha indicado la necesidad o conveniencia de las mismas.

3.1.5. TRABAJOS COMPLEMENTARIOS. La Empresa Programadora tiene la obligación de realizar todos los trabajos

complementarios que sean indispensables para ejecutar cualquier parte del Programa especificadas en cualquiera de los documentos del Proyecto, aunque en el, no figuren explícitamente mencionadas dichos trabajos complementarios. Todo ello sin variación del importe contratado.

3.1.6. MODIFICACIONES. La Empresa Programadora está obligada a realizar los trabajos que se le encarguen

resultantes de modificaciones del Programa, tanto en aumento como disminución o simplemente variaciones, siempre y cuando el importe de las mismas no altere en más o menos de un 25% del valor contratado.

La valoración de las mismas se hará de acuerdo, con los valores establecidos en el

presupuesto entregado por la Empresa Programadora y que ha sido tomado como base del contrato. El Técnico Director del Programa está facultado para introducir las modificaciones de acuerdo con su criterio, en cualquier parte del Programa, durante la creación, siempre que cumplan las condiciones técnicas referidas en el Proyecto y de modo que ello no varíe el importe total del Programa.

50

3.1.7. PROGRAMA DEFECTUOSO. Cuando la Empresa Programadora halle cualquier parte del Programa defectuosa que

no se ajuste a lo especificado en el Proyecto o en este Pliego de Condiciones, el Técnico Director podrá aceptarlo o rechazarlo; en el primer caso, éste fijará el precio que crea justo con arreglo a las diferencias que hubiera, estando obligada la Empresa Programadora a aceptar dicha valoración, en el otro caso, se reconstruirá a expensas de la Empresa Programadora la parte mal ejecutada sin que ello sea motivo de reclamación económica o de ampliación del plazo de ejecución.

3.1.8. MEDIOS AUXILIARES Serán de la Empresa Programadora todos los medios y máquinas auxiliares que sean

necesarias para la ejecución del Programa. 3.1.9. CONSERVACIÓN DEL PROGRAMA. Es obligación de la Empresa Programadora la conservación en perfecto estado del

programa hasta la fecha de recepción definitiva por la Empresa Usuaria, y corren a su cargo los gastos derivados de ello.

3.1.10. RECEPCIÓN DEL PROGRAMA. 3.1.10.1. RECEPCIÓN PROVISIONAL: Una vez terminado el Programa, tendrá lugar la recepción provisional y para ello se

practicará en ellas un detenido reconocimiento por el Técnico Director y la Empresa Usuaria en presencia de la Empresa Programadora, levantando acta y empezando a correr desde ese día el plazo de garantía si se halla en estado de ser admitido.

De no ser admitido se hará constar en el acta y se darán instrucciones a la Empresa

Programadora para subsanar los defectos observados, fijándose un plazo para ello, expirando el cual se procederá a un nuevo reconocimiento a fin de proceder a la recepción provisional.

3.1.10.2. LICENCIA Y DERECHOS. Una vez efectuada la recepción provisional se le entregará a la Empresa Usuaria una

licencia de derecho de uso del programa, una copia del Programa y un Manual de Instalación y Uso. Esta licencia da derecho a instalar el programa en un ordenador. Por cada licencia de derecho de uso que se disponga, sólo puede haber una copia en uso, es decir instalada en un ordenador.

No se podrá copiar, instalar en otro ordenador, ejecutar en público o aiq ' uilar la copia entregada del programa sin la previa autorización de la Empresa Programadora. Si se quiere instalar el Programa en otro ordenador se tendrá que desinstalar previamente del primero.

51

El Programa solo se puede vender, tal cual, sin modificarlo, completamente con la licencia de derecho de uso del Programa, la copia del Programa y el Manual de Instalación y Uso.

3.1.10.3. PLAZO DE GARANTÍA. El plazo de garantía será como mínimo de un año, contado desde la fecha de la

recepción provisional, o bien el que se establezca en el contrato también contado desde la misma fecha. Durante este período queda a cargo de la Empresa Programadora la conservación del Programa y el arreglo de los errores observados.

3.1.10.4. RECEPCIÓN DEFINITIVA. Se realizará después de transcurrido el plazo de garantía de igual forma que la

provisional. A partir de esta fecha cesará la obligación de la Empresa Programadora de conservar y reparar a su cargo los defectos observados.

3.1.11. CONTRATACIÓN DE LA EMPRESA PROGRAMADORA. 3.1.1 1.1. MODO DE CONTRATACIÓN. El conjunto del Programa lo realizará la empresa escogida por concurso-subasta. 3.1.11.2. PRESENTACIÓN. Las empresas seleccionadas para dicho concurso deberán presentar sus proyectos en

sobre lacrado, antes del 15 de Febrero de 2002 en el domicilio de la Empresa Usuaria. 3.1.11.3. SELECCIÓN. La empresa escogida será anunciada la semana siguiente a la conclusión del plazo de

entrega. Dicha empresa será escogida de mutuo acuerdo entre la Empresa Usuaria y el Director Técnico, sin posible reclamación por parte de las otras empresas concursantes.

3.1.12. FIANZA. En el contrato se establecerá la fianza que la Empresa Programadora deberá depositar

en garantía del cumplimiento del mismo, o, se convendrá una retención sobre los pagos realizados a cuenta de Programa realizado.

De no estipularse la fianza en el contrato se entiende que se adopta como garantía

una retención del 5% sobre los pagos a cuenta citados. En el caso de que la Empresa Programadora se negase a hacer por su cuenta los

trabajos para ultimar el Programa en las condiciones contratadas, o a atender la garantía, la Empresa Usuaria podrá ordenar ejecutarlas a un tercero, abonando su importe con cargo a la retención o fianza, sin perjuicio de las acciones legales a que tenga derecho la Empresa Usuaria si el importe de la fianza no bastase.

La fianza retenida se abonará a la Empresa Programadora en un plazo no superior a

treinta días una vez firmada el acta de recepción definitiva del Programa.

52

3.2. CONDICIONES ECONÓMICAS. 3.2.1. ABONO DEL PROGRAMA. En el contrato se deberá fijar detalladamente la forma y plazos que se abonarán las

partes realizadas del Programa. Las liquidaciones parciales que puedan establecerse tendrán carácter de documentos provisionales a buena cuenta, sujetos a las certificaciones que resulten de la liquidación final. No suponiendo, dichas liquidaciones, aprobación ni recepción del trabajo que comprenden.

Terminado el Programa se procederá a la liquidación final que se efectuará de

acuerdo con los criterios establecidos en el contrato. 3.2.2. PRECIOS. La Empresa Programadora presentará, al formalizarse el contrato, relación de los

precios de las unidades del Programa que integran el proyecto, los cuales de ser aceptados tendrán valor contractual y se aplicará a las posibles variaciones que puedan haber.

Estos precios unitarios, se entiende que comprenden la ejecución total de la unidad

del Programa, incluyendo todos los trabajos aún los complementarios y los materiales así como la parte proporcional de imposición fiscal, las cargas laborales y otros gastos repercutibles.

En caso de tener que realizarse unidades de Programa no previstas en el proyecto, se

fijará su precio entre el Técnico Director y la Empresa Programadora antes de iniciar el Programa y se presentará a la Empresa Usuaria para su aceptación o no.

3.2.3. REVISIÓN DE PRECIOS. En el contrato se establecerá si la Empresa Programadora tiene derecho a revisión de

precios y la fórmula a aplicar para. calcularla. En defecto de esta última, se aplicará a juicio del Técnico Director alguno de los criterios oficiales aceptados.

3.2.4. PENALIZACIONES. Por retraso en los plazos de entrega del Programa, se podrán establecer tablas de

penalización cuyas cuantías y demoras se fijarán en el contrato. 3.2.5. CONTRATO. El contrato se formalizará mediante documento privado, que podrá elevarse a

escritura pública a petición de cualquiera de las partes. Comprenderá la adquisición de todos los materiales, transporte, mano de obra, medios auxiliares para la ejecución del Programa proyectado en el plazo estipulado, así como la reconstrucción de las unidades defectuosas, la realización de las partes complementarias y las derivadas de las

53

modificaciones que se introduzcan durante la ejecución, éstas últimas en los términos previstos.

La totalidad de los documentos que componen el Proyecto Técnico del Programa

serán incorporados al contrato y tanto el contratista como la Empresa Usuaria deberá firmarlos en testimonio de que los conocen y aceptan.

3.2.6. RESPONSABILIDADES. La Empresa Programadora es la responsable de la ejecución del Programa en las

condiciones establecidas en el proyecto y en el contrato. Como consecuencia de ello vendrá obligado a la eliminación de lo mal ejecutado y a su reconstrucción correctamente sin que sirva de excusa el que el Técnico Director haya examinado y reconocido el Programa.

La Empresa Programadora es la única responsable de todas las contravenciones que

ella o su personal cometan durante la ejecución del Programa u operaciones relacionadas con el mismo. También es responsable de los daños que por errores, inexperiencia o empleo de métodos inadecuados se produzcan en la Empresa Usuaria.

la Empresa Programadora es la única responsable del incumplimiento de las

disposiciones vigentes en la materia laboral respecto de su personal. 3.2.7. RESCISIÓN DEL CONTRATO 3.2.7.1. CAUSAS DE RESCISIÓN. Se consideraran causas suficientes para la rescisión del contrato las siguientes: · Primero: Muerte o incapacitación de La Empresa Programadora. · Segunda: La quiebra de la Empresa Programadora. · Tercera: Modificación del proyecto cuando produzca alteración en más o

menos 25% del valor contratado. · Cuarta: Modificación de las unidades de Programa en número superior al

40% del original. · Quinta : La no iniciación de la programación en el plazo estipulado cuando

sea por causas ajenas a la Empresa Programadora. · Sexta : La suspensión de la programación ya iniciada siempre que el plazo

de suspensión sea mayor de seis meses. · Séptima: Incumplimiento de las condiciones del Contrato cuando implique

mala fe. · Octava : Terminación del plazo de ejecución del Programa sin haberse

llegado a completar éste. · Novena : Actuación de mala fe en la ejecución de los trabajos. · Décima: Destajar o subcontratar la totalidad o parte del Programa a terceros

sin la autorización del Técnico Director y la Empresa Usuaria.

54

3.2.8. LIQUIDACIÓN EN EL CASO DE RESCISIÓN DEL CONTRATO. Siempre que se rescinda el Contrato por causas anteriores o bien por acuerdo de

ambas partes, se abonará a la Empresa Programadora las unidades de Programa ya terminadas.

Cuando se rescinda el contrato llevará implícito la retención de la fianza para obtener

los posibles gastos de conservación de el período de garantía y los derivados del mantenimiento hasta la fecha de nueva adjudicación.

3.3. CONDICIONES FACULTATIVAS.

3.3.1. PERSONAL. La Empresa Programadora tendrá al frente de la realización del Programa un

encargado con autoridad sobre los demás operarios y conocimientos acreditados y suficientes para la ejecución del Programa.

El encargado recibirá, cumplirá y transmitirá las instrucciones y ordenes del Técnico

Director de la obra. La Empresa Programadora tendrá el número y clase de operarios que haga falta para

el volumen y naturaleza de los trabajos que se realicen, los cuales serán de reconocida aptitud y experimentados en el oficio. La Empresa Programadora estará obligada a separar de la programación, a aquel personal que a juicio del Técnico Director no cumpla con sus obligaciones, realice el trabajo defectuosamente, bien por falta de conocimientos o por obrar de mala fe.

3.4. CONDICIONES TÉCNICAS 3.4.1. REQUERIMIENTOS DE HARDWARE Para que el Programa pueda funcionar con cierta agilidad se aconseja tener como

mínimo el siguiente Hardware: PC Pentium III con processador a 733MHz como mínimo 256 Mb de RAM como

mínimo 3 Mb de espacio libre en el disco duro. Ratón Microsoft o compatible.

Monitor SVGA con una resolución de 800 * 600 píxeles como mínimo.

3.4.2. REQUERIMIENTOS DE SOFTWARE Para que pueda funcionar el Programa se tendrá que tener instalado en el ordenador

como mínimo el Software siguiente con sus respectivas licencias. · Microsoft Windows 95 o posterior.

55

4 Anexo

CÓDIGO -Funciones asociadas al menú principal -function varargout = Final_gui(varargin) % Aquest GUI es el menu principal on s'hi podran executar les funcions % % - Carregar l'arxiu principal de dades: per alguns metodes sera % necessari algun altre arxiu, pero aixo es veura cadascun dels % menus corresponents. Per seleccionar l'arxiu, cal clicar sobre % el boto 'Carregar dades' % % - Seleccionar el metode de preprocessament: no es necessari % normalitzar el fixer de dades per continuar, pero s'ofereix % l'oportunitat d'escalar, centrar, normalitzar per files o per % columnes. Tambe es poden plotejar les dades. Per triar metode, % es clica en la barra sota la inscripcio 'Pre-processament' % % - Seleccionar el metode estadistic: aqui es on es pot fer un % primer analisi exhaustiu de les dades. Els metodes disponibles % son PCA, Cluster Analysis, PCR, PLS i DFA. Cada metode tindra % el seu propi menu i parametres. El metode s'escull en el menu % on apareixen tots els metodes estadistics % % - Seleccionar el metode neural: aqui s'entra de ple en les % xarxes neurals. Es poden executar els principals metodes (MLP, % SOM, LVQ, FUZZY i FUZZY ART), cadascun amb el seu propi menu % on configurar els parametres corresponents.El metode s'escull % en el quadre on apareixen tots els metodes neurals % % Tant els metodes de pre-processat,com els estadistics i els neurals, % requeriran ser activats per mitja del polsador GO que s'adjunta amb % cada menu. De no ser aixi,no es podra executar el metode seleccionat % (en el cas del processat significara que es treballa amb l'arxiu de % dades original). warning off if nargin == 0 fig = openfig(mfilename,'reuse'); handles = guihandles(fig); guidata(fig, handles); if nargout > 0 varargout{1} = fig; end elseif ischar(varargin{1}) try [varargout{1:nargout}] = feval(varargin{:}); catch disp(lasterr); end end % -------------------------------------------------------------------- function Load_Callback(h, eventdata, handles, varargin) % Es carrega l'arxiu de dades. Agafades les dades, ja no es treballa % mes amb aquest arxiu, les dades es prenen del fitxer dataini.mat que

56

% es crea, on s'hi guarden les dades i el nom original del fitxer.Aixo % es fa per controlar que els metodes que s'apliquen corresponen amb % les dades carregades en memoria actualment. % Inicialitzacions set(handles.Pre,'Value',1); set(handles.Est,'Value',1); set(handles.Neu,'Value',1); nomini=[];resultsini=[]; [filename,pathname]=uigetfile('*.*','Carregar fitxer dades'); if (filename ~= 0) nomini=[pathname,filename]; resultsini=load(nomini); a=exist('resultsini'); if (a == 0) %No es carrega cap arxiu nomini=[];resultsini=[]; end end if (exist('c:\matlabr12\work\datapre.mat') ~= 0) %Quan es carreguen noves dades, els fitxers de processat (veure %go_pre.m) s'inicialitzen novament nompre=[];resultspre=[];metpre=1;valorpre=0; save('c:\matlabr12\work\datapre.mat','nompre','resultspre','metpre','valorpre'); end set(handles.File,'String',nomini); save('c:\matlabr12\work\dataini.mat','resultsini','nomini'); % -------------------------------------------------------------------- function Go_pre_Callback(h, eventdata, handles, varargin) % Nomes s'executa si s'han carregat dades. Primer s'escull el metode % i despres activar-lo polsant GO. La funcio go_pre sera l'encarregada % de dur a terme el processat de les dades. a=exist('c:\matlabr12\work\dataini.mat'); %mira q existan los datos o q se han cargado if (a ~= 0) %si no existen los datos load('c:\matlabr12\work\dataini.mat'); met=get(handles.Pre,'Value'); %Es passa el metode escollit. Parametre important despres go_pre(nomini,resultsini,met); end % -------------------------------------------------------------------- function Plot_Callback(h, eventdata, handles, varargin) % Es dibuixen les dades, ja siguin nomes les originals, o tambe les % processades (si s'ha pitjat GO). No es necessari pel desenvolupament % del programa plotejar les dades.Aqui es mira si s'ha creat el fitxer % datapre.mat en preprocessar les dades (veure go_pre.m) per saber que % cal dibuixar. met=get(handles.Pre,'Value'); a=exist('c:\matlabr12\work\dataini.mat'); b=exist('c:\matlabr12\work\datapre.mat'); if a load('c:\matlabr12\work\dataini.mat'); end if b load('c:\matlabr12\work\datapre.mat'); end

57

if (b & a & (resultspre ~= []) & (resultsini ~= []) & (nompre == nomini) & (metpre == met)) num_of_plots=2; %S'ha fet un processat de les dades elseif (a & (resultsini ~= [])) %No s'ha fet un processat de les dades. El fitxer datapre.mat %s'actualitza,no conte informacio sobre preprocessament num_of_plots=1;resultspre=[];nompre=nomini; save('c:\matlabr12\work\datapre.mat','resultspre','nompre'); else num_of_plots=0; %No hi ha res carregat. No es ploteja end switch(num_of_plots) case 0 nadena=0; case 1 close(figure(1)) figure(1) plot(resultsini,'b'); %Es dibuixen dades originals xlabel('Nº de mostres'); ylabel('Dades originals'); title('DADES SENSE PROCESSAR','FontSize',14); case 2 close(figure(1)) figure(1) subplot(2,1,1); plot(resultsini,'b'); %Es dibuixen dades originals ylabel('Dades originals'); title('DADES ORIGINALS vs. PROCESSADES','FontSize',14); subplot(2,1,2); plot(resultspre,'r'); %S'adjunten dades processades xlabel('Nº de mostres'); ylabel('DADES PROCESSADES'); end % -------------------------------------------------------------------- function Go_est_Callback(h, eventdata, handles, varargin) % Un cop escollit el metode estadistic a executar, cal premer GO per a % fer apareixer el menu corresponent. La variable global STATUS, usada % tambe en menus posteriors,indica si les dades que s'han processat es % corresponen a les dades originals carregades ( aqui es on variables % com el nom de l'arxiu o el metode de processat agafen importancia, % permetent als proxims menus saber si es pot o no treballar amb dades % processades. %en esta funcion una vez se ha seleccionado el metodo estadistico se abre el %formulario correspondiente a dicho metodo global STATUS; met=get(handles.Pre,'Value'); %de aqui saca el el metodo elegido a=exist('c:\matlabr12\work\dataini.mat'); %aqui la a y la b obtendran el valor 1 si existe el fichero b=exist('c:\matlabr12\work\datapre.mat'); %y si no obtendran el valor 0 if a %mira si existe el fichero de datos orig. load('c:\matlabr12\work\dataini.mat'); end if b %mira si se ha creado el fich de datos preproces. load('c:\matlabr12\work\datapre.mat'); end if (b & a & (resultspre ~= []) & (resultsini ~= []) & (nompre == nomini) & (metpre == met)) %si existen los 2 archivos es q se han %preprocesado los datos (resultspre diferente de cero implica q existe) %Les dades processades provenen de l'arxiu original

58

STATUS=2; %si se han preprocesado los datos STATUS vale 2 elseif (a & (resultsini ~= [])) %Les dades processades no son de l'arxiu original o no existeixen %(es vol treballar amb les originals) STATUS=1;resultspre=[];nompre=nomini; save('c:\matlabr12\work\datapre.mat','resultspre','nompre'); else STATUS=0; end if (STATUS ~= 0) met=get(handles.Est,'Value'); if (met == 2) menu_pca; end if (met == 3) menu_cluster; end if (met == 4) menu_pcr; end if (met == 5) menu_pls; end if (met == 6) menu_dfa; end if (met == 7) %añado nuevo metodo estadistico gasel gaselnew; end else nadena=0; end % -------------------------------------------------------------------- function Go_neu_Callback(h, eventdata, handles, varargin) % Un cop escollit el metode neural a executar,cal premer GO per a fer % apareixer el menu corresponent. La variable global STATUS, usada en % menus posteriors,indica si les dades que s'han processat corresponen % a les dades originals carregades (aqui es on variables com el nom de % l'arxiu o el metode de processat agafen importancia, permetent als % proxims menus saber si es pot o no treballar amb dades processades. %EXACTAMENTE LA MISMA FUNCION Q ANTES PERO CON LOS MET NEURALES global STATUS; met=get(handles.Pre,'Value'); a=exist('c:\matlabr12\work\dataini.mat'); b=exist('c:\matlabr12\work\datapre.mat'); if a load('c:\matlabr12\work\dataini.mat'); %si existe el archivo devolvera un 1 y si no un 0 end if b load('c:\matlabr12\work\datapre.mat'); end if (b & a & (resultspre ~= []) & (resultsini ~= []) & (nompre == nomini) & (metpre == met)) %Les dades processades provenen de l'arxiu original STATUS=2; elseif (a & (resultsini ~= [])) %Les dades processades no son de l'arxiu original o no existeixen %(es vol treballar amb les originals) STATUS=1;resultspre=[];nompre=nomini; save('c:\matlabr12\work\datapre.mat','resultspre','nompre'); else STATUS=0;

59

end if (STATUS ~= 0) met=get(handles.Neu,'Value'); if (met == 2) menu_mlp; end if (met == 3) menu_som; end if (met == 4) menu_lvq; end if (met == 5) menu_fuzzyart; end if (met == 6) menu_fuzzyartmap; end end % -------------------------------------------------------------------- function Pre_Callback(h, eventdata, handles, varargin) % Aquesta funcio no te objectius, nomes justificar que s'actua un cop % es selecciona un metode determinat (recordar que si no es prem GO, % el metode no s'executa. met_pre=get(h,'value'); % -------------------------------------------------------------------- function Est_Callback(h, eventdata, handles, varargin) % Aquesta funcio no te objectius, nomes justificar que s'actua un cop % es selecciona un metode determinat (recordar que si no es prem GO, % el metode no s'executa. met_est=get(h,'value'); % -------------------------------------------------------------------- function Neu_Callback(h, eventdata, handles, varargin) % Aquesta funcio no te objectius, nomes justificar que s'actua un cop % es selecciona un metode determinat (recordar que si no es prem GO, % el metode no s'executa. met_meu=get(h,'value'); % -------------------------------------------------------------------- function salida_Callback(h, eventdata, handles, varargin) % Crida a la sortida del GUI. salida; % -------------------------------------------------------------------- function varargout = Info_pre_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.Info_pre. disp('Info_pre Callback not implemented yet.')

60

-Funciones asociadas al menú MLP function varargout = Menu_mlp(varargin) % Aquest GUI executa un analisi MLP sobre les dades. Aqui es pot % % - Escollir entre les dades processades (cas d'haver-se fet un % processat previ) o be quedar-se amb les dades originals. Nomes % cal escollir entre una de les dues caselles inicials % % - Seleccionar l'arxiu que conte la matriu referents a les % categories % % - Extreure files o columnes de la matriu en cas de veure que % algun element de la matriu de dades es superflu. Cal premer % GO per continuar % % - Donar nom a la xarxa, escollir el nombre de capes de la xarxa, % donant per evident una capa d'entrada, definir-ne el nombre de % neurones i tambe la funcio de transferencia i assignar funcio % d'entrenament a la xarxa. Premer GO per crear la xarxa % % - Opcionalment, es poden modificar dos parametres d'entrenament, % els epochs i el goal o objectiu final. Tambe caldra escollir % entre simular les dades dent leave-1-out o validacio creuada % % - La xarxa es podra reinicialitzar, i les dades de la simulacio % es podran guardar en un arxiu .mat warning off if nargin == 0 fig = openfig(mfilename,'reuse'); handles = guihandles(fig); guidata(fig, handles); if nargout > 0 varargout{1} = fig; end elseif ischar(varargin{1}) try [varargout{1:nargout}] = feval(varargin{:}); catch disp(lasterr); end end % -------------------------------------------------------------------- function Processed_data_Callback(h, eventdata, handles, varargin) % La variable global STATUS permet saber si les dades s'han processat % o no.En cas afirmatiu, aquesta casella es activable. global STATUS; %la ponemos pq la utilizamos para saber si los datos han sido preprocesados o no % Inicialitzacions a=[]; set(handles.Original_data,'Value',0); %aqui fuerza donde se pone el puntito para

61

%seleccionar los datos originales a cero set(handles.Go_extract,'Visible','off'); set(handles.Targets,'String',a); %fijate q antes ha inicializado a=0 y ahora el edit box de los %targets lo ha inicializado con a, es decir con cero set(handles.Nom_xarxa,'Visible','off'); %esto hace q al principio no se vea el %edit box q pregunta como quieres q se llame la red, o q no se pueda introducir el nombre if (STATUS == 2) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Original_data_Callback(h, eventdata, handles, varargin) % La variable global STATUS permet saber si les dades s'han processat % o no.Tant si s'han processat com si no,aquesta casella es activable. global STATUS; % Inicialitzacions a=[]; set(handles.Processed_data,'Value',0); %aqui elegimos los datos originales con lo cual forzamos a cero el resto de opciones para poner puntito, es decir la opcion de los datos procesados, ya q no la seleccionamos %Se trata de conseguir la exclusion mutua=>no podemos poner el puntito o seleccionar datos procesados y a su vez los originales para trabajar set(handles.Go_extract,'Visible','off'); set(handles.Targets,'String',a); set(handles.Nom_xarxa,'Visible','off'); if (STATUS == 2) | (STATUS == 1) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Targets_name_Callback(h, eventdata, handles, varargin) % Es carrega l'arxiu de categories. Agafades les dades,ja no s'usa mes % aquest arxiu,les dades es prenen del fitxer. global MATRIZ_TOTAL; global NN; %Per saber on acaben dades i comencen classes global rtglobal; global datos; global resultspre; global resultsini; % Inicialitzacions a=get(handles.Processed_data,'Value'); %a es una variable q coge el valor del radiobutton, es decir mira si hay puntito o no, o sea si esta seleccionado o no b=get(handles.Original_data,'Value'); %idem q el anterior nomtar=[];resultstar=[];matriz_data_targets=[];n1=0; %inicializamos... set(handles.Go_extract,'Visible','off');

62

set(handles.Nom_xarxa,'Visible','off'); if a %miramos si el usuario ha seleccionado los datos preprocesados o no load('c:\matlabr12\work\datapre.mat'); data=resultspre; %si ha seleccionado los dat. prep. la variable data pilla %los datos preproc. elseif b %si el usuario selecciona los originales... load('c:\matlabr12\work\dataini.mat'); data=resultsini; %la variable data coge los valores iniciales sin preprocesar else data=[]; %y si no se ha seleccionado ninguno de los 2 radiobuttons entonces %data se inicializa a cero end if (data ~= []) %si data diferente de cero... o sea q hemos hecho alguna seleccion... [filename,pathname]=uigetfile('*.*','Carregar fitxer targets'); %cogemos el %fichero targets if (filename ~= 0) %si el nombre del fichero es diferente de cero, o sea q %introducimos algo nomtar=[pathname,filename]; %se coge la ruta de donde esta el fichero y %su nombre resultstar=load(nomtar); %una var. coge los datos de antes rtglobal=resultstar; datos=data; c=exist('resultstar'); %se comprueba q exista el fichero if (c == 0) %si no existe dicho archivo... %No es carrega cap arxiu nadena=0; else %si resulta q si q existe se coge el tamaño de la matriz de %targets para emplearla %mas tarde [m1,n1]=size(data); %aki se mira el tamaño de los datos preprocesados %o no [m2,n2]=size(resultstar); %aki se mira y almacena el tamaño del %fichero de targets if (m1 == m2) %si todo es correcto se tiene q cumplir q para cada %medida hay una clase %La matriu conte dades i categories matriz_data_targets=[data resultstar]; %lo mete todo datos y %targets en una matriz set(handles.Go_extract,'Visible','on'); else nadena=0; end end else nadena=0; end else nadena=0; end set(handles.Targets,'String',nomtar); %esto es para mostrar simplemente en la

63

%editbox el archivo de targets seleccionado %asi como su path MATRIZ_TOTAL=matriz_data_targets; %simplemente a la matriz donde estan datos y %targets la llama asi ahora NN=n1; %esto es el numero de sensores % -------------------------------------------------------------------- function Row_yes_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; %declaro variable global la matriz q contiene tanto datos %como targets % Inicialitzacions a=get(handles.Processed_data,'Value'); %vuelvo a mirar si coge los datos %preprocesados o los originales b=get(handles.Original_data,'Value'); c=[]; %inicializo a cero var auxiliar set(handles.Nom_xarxa,'Visible','off'); %no permitir acceder al editbox de %nomdexarxa set(handles.Row_no,'Value',0); %la presente funcion se llama row_yes, es decir %fila_si con lo cual se ejecuta esta funcion pq el %usuario ha decidido extraer datos, por %eso ponemos la otra opcion a cero, la de row_no, %pq no la keremos y tenemos q hacer la exclusion mutua set(handles.Row,'String',c); %inicializamos a cero el contenido string de la edit %box cuyo tag es row set(handles.Row,'Visible','off'); mat=MATRIZ_TOTAL; %simplemente cambiamos de nombre a la var. matriz_total para %mas comodidad if (a | b) & (mat ~= []) %si selecciona una de las 2 opciones, datos preproc. u %datos originales y ademas la matriz q contiene datos y targets es distinta de %cero if (get(h,'Value') == 1) set(handles.Row,'Visible','on'); %entonces puedes escribir las filas q %quieres extraer else set(h,'Value',0); %de otro modo no end else set(h,'Value',0); end % -------------------------------------------------------------------- function Row_no_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; % Inicialitzacions a=get(handles.Processed_data,'Value'); %idem q en la func. anterior b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off');

64

set(handles.Row_yes,'Value',0); set(handles.Row,'String',c); set(handles.Row,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Col_yes_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. %Esta funcion es igual q las 2 anteriores pero lo q hace es extraer las columnas en vez %de las filas global MATRIZ_TOTAL; % Incialitzacions a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.Col_no,'Value',0); set(handles.Col,'String',c); set(handles.Col,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1) set(handles.Col,'Visible','on'); else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Col_no_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; % Inicialitzacions a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.Col_yes,'Value',0); set(handles.Col,'String',c); set(handles.Col,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % --------------------------------------------------------------------

65

function Go_extract_Callback(h, eventdata, handles, varargin) % Si la matriu dades-targets existeix, s'extreuran les dades que es % desitgin. Un cop extretes, es guardaran en un arxiu .mat temporal i % s'activaran caselles per crear la xarxa global MATRIZ_TOTAL; global NN; %Columnes arxiu dades (p.e. nº sensors) % Inicialitzacions a=get(handles.Processed_data,'Value'); %otra vez miramos si selecciona datos %preprocesados u original. b=get(handles.Original_data,'Value'); filas=str2num(get(handles.Row,'String')); %coge el nº de filas a extraer q sera un string o caracter y le aplica la funcion str2num para convertir el %caracter en entero columnas=str2num(get(handles.Col,'String')); %idem f=[]; %var. aux. inicializada a 0 para emplearla posteriormente set(handles.Nom_xarxa,'Visible','off'); %todo lo q viene ahora es para permitir o no en las editbox siguientes set(handles.Capa1,'Visible','off');set(handles.Capa1,'Value',0); set(handles.Capa2,'Visible','off');set(handles.Capa2,'Value',0); set(handles.Capa3,'Visible','off');set(handles.Capa3,'Value',0); set(handles.Capa,'Visible','off');set(handles.Capa,'Value',1); %aqui le da el %valor especifico 1 pq se %trata de un popmenu q %tiene varias posiciones %con varias opciones y %una de ellas tiene q ser %neutra en este caso las rallitas (----) set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); %tb es popmenu set(handles.Go_new,'Visible','off'); set(handles.Num_neu,'Visible','off'); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Num_neu,'String',f);set(handles.Transfer_xarxa,'Value',1); %tb es popmenu set(handles.Savedata,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) %si se ha cogido los datos preproc. u originales y la matriz q contiene los %datos y los targets es diferente de 0 data=mat; %la variable data pasa a contener a la matriz q contiene datos y targets else data=[]; %si no la var. data se inicializa a 0 end if (data ~= []) %miramos si data es diferente de 0 dat=data; %si es asi la var. dat coge el valor de data, o sea la matriz q %contiene datos y targets % Cont2 sera el nº de columnes de dades de la matriu un cop feta % l'extraccio contador2=NN; %ahora la var. contador2 toma el valor del num de sensores o nº de columnas if (filas ~= []) [m,n]=size(filas); for i=1:n-1 for j=i+1:n if (filas(i) == filas(j)) % Fila a extreure repetida filas(j)=1e6; end end end

66

for i=1:n if (filas(i) <= 0) % No existeix fila 0 en Matlab filas(i)=1e6; end if (filas(i) > n) % No existeix aquesta fila en la matriu filas(i)=1e6; end end dat=delsamps(dat,filas); end if (columnas ~=[]) %lo mismo q antes pero con las columnas [m,n]=size(columnas); for i=1:n-1 for j=i+1:n if (columnas(i) == columnas(j)) % Columna a extreure repetida columnas(j)=1e6; end end end for i=1:n if (columnas(i) <= 0) % No existeix columna 0 en Matlab columnas(i)=1e6; end if (columnas(i) > NN) % No es suprimeixen columnes de classes columnas(i)=1e6; end end contador=0; if (columnas ~= []) for i=1:length(columnas) if (columnas(i) ~= 1e6) % Si s'incrementa contador, % es que la columna es suprimeix contador=contador+1; end end end contador2=NN-contador; dat=delsamps(dat',columnas)'; end if (contador2 > 0) for i=1:contador2 % Definicio de la matriu de rangs (util per crear xarxa) rangmax(i)=max(dat(:,i));rangmin(i)=min(dat(:,i)); %Esta lo hace para obtener la variable %PR necesaria para construir la red mat_rang(i,:)=[rangmin(i) rangmax(i)]; end n_col_data=contador2; else mat_rang=[];n_col_data=0; end set(handles.Nom_xarxa,'Visible','on'); set(handles.Nom_xarxa,'String',f); else dat=[];mat_rang=[];n_col_data=0; end % Creacio d'arxiu temporal amb les dades mes importants per fer MLP save('c:\matlabr12\work\datamlp.mat','data','dat','mat_rang','n_col_data'); % -------------------------------------------------------------------- function Nom_xarxa_Callback(h, eventdata, handles, varargin)

67

% La variable global conte informacio de cada capa de la xarxa, i es % reseteja cada cop que introduim un nou nom a la xarxa. Premer ENTER % per seguir creant la xarxa. global DATAXARXA; % Inicialitzacions a=get(h,'String'); %esto supongo q coge del control q estamos hablando, o sea del %editbox q hay para poner el nombre de la red por eso no se le %pone la extension handle etc... b=[]; set(handles.Capa1,'Visible','off');set(handles.Capa1,'Value',0); %pone a off los 3 %controles para seleccionar las capas si no introducimos antes el nombre de la red set(handles.Capa2,'Visible','off');set(handles.Capa2,'Value',0); set(handles.Capa3,'Visible','off');set(handles.Capa3,'Value',0); set(handles.Capa,'Visible','off');set(handles.Capa,'Value',1); %"value" de los %popmenus a '1'.... set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Go_new,'Visible','off'); set(handles.Num_neu,'Visible','off'); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Num_neu,'String',1);set(handles.Transfer_xarxa,'Value',1); set(handles.Reset_net,'Visible','off'); DATAXARXA=[]; %de momento no tenemos datos para crear la red, por eso esta var. %global vale 0 if (exist('c:\matlabr12\work\datamlp.mat') ~= 0) load('c:\matlabr12\work\datamlp.mat'); if (a ~= []) & (dat ~= []) & (mat_rang ~= []) & (n_col_data ~= 0) % Un cop creada la matriu data-targets i donat un nom, ja % es poden definir altres parametres. set(handles.Capa1,'Visible','on'); %ahora ya nos deja seleccionar el num %de capas q queremos... set(handles.Capa2,'Visible','on'); set(handles.Capa3,'Visible','on'); else set(h,'String',b); %si la editbox donde le damos nombre a la red o al %archivo q contiene la matriz end end % -------------------------------------------------------------------- function Capa1_Callback(h, eventdata, handles, varargin) % La variable global conte informacio de cada capa de la xarxa, i es % reseteja cada cop que es defineix una xarxa sense capa oculta. global DATAXARXA; % Inicialitzacions a=get(h,'Value'); b=get(handles.Nom_xarxa,'String'); set(handles.Capa2,'Value',0);set(handles.Capa3,'Value',0); set(handles.Capa,'Visible','off');set(handles.Capa,'Value',1); set(handles.Num_neu,'Visible','off');set(handles.Num_neu,'String',1); set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Transfer_xarxa,'Value',1); set(handles.Ok_capa,'Visible','off'); set(handles.Go_new,'Visible','off'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); DATAXARXA=[]; if (get(h,'Value') == 1) & (b ~= []) set(handles.Capa,'Visible','on');

68

% En el selector de capa nomes es podra escollir una capa [1] % (la de sortida) c=[1]; set(handles.Capa,'String',c); else set(h,'Value',0); end % -------------------------------------------------------------------- function Capa2_Callback(h, eventdata, handles, varargin) % La variable global conte informacio de cada capa de la xarxa, i es % reseteja cada cop que es defineix una xarxa amb 1 capa oculta. global DATAXARXA; % Inicialitzacions a=get(h,'Value'); b=get(handles.Nom_xarxa,'String'); set(handles.Capa1,'Value',0);set(handles.Capa3,'Value',0); set(handles.Capa,'Visible','off');set(handles.Capa,'Value',1); set(handles.Num_neu,'Visible','off');set(handles.Num_neu,'String',1); set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Transfer_xarxa,'Value',1); set(handles.Ok_capa,'Visible','off'); set(handles.Go_new,'Visible','off'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); DATAXARXA=[]; if (get(h,'Value') == 1) & (b ~= []) set(handles.Capa,'Visible','on'); % En el selector de capa nomes es podran escollir 2 capes [1 2] % (la 2º de sortida) c=[1 2]; set(handles.Capa,'String',c); else set(h,'Value',0); end % -------------------------------------------------------------------- function Capa3_Callback(h, eventdata, handles, varargin) % La variable global conte informacio de cada capa de la xarxa, i es % reseteja cada cop que es defineix una xarxa amb 2 capa oculta. global DATAXARXA; % Inicialtzacions a=get(h,'Value'); b=get(handles.Nom_xarxa,'String'); set(handles.Capa1,'Value',0);set(handles.Capa2,'Value',0); set(handles.Capa,'Visible','off');set(handles.Capa,'Value',1); set(handles.Num_neu,'Visible','off');set(handles.Num_neu,'String',1); set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Transfer_xarxa,'Value',1); set(handles.Ok_capa,'Visible','off'); set(handles.Go_new,'Visible','off'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); DATAXARXA=[]; if (get(h,'Value') == 1) & (b ~= []) set(handles.Capa,'Visible','on'); % En el selector de capa nomes es podran escollir 3 capes [1 2 3] % (la 3º de sortida) c=[1 2 3]; set(handles.Capa,'String',c); else

69

set(h,'Value',0); end % -------------------------------------------------------------------- function Capa_Callback(h, eventdata, handles, varargin) % De la capa que aqui es seleccioni es definira el nºde neurones i la % funcio de transferencia. Si la capa seleccionada es la de sortida, % el nº de neurones quedara fixat segons el fitxer de targets % Inicializatcions a=get(h,'Value'); c1=get(handles.Capa1,'Value');c2=get(handles.Capa2,'Value'); c3=get(handles.Capa3,'Value'); set(handles.Num_neu,'Visible','off');set(handles.Num_neu,'String',1); set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Transfer_xarxa,'Value',1); set(handles.Ok_capa,'Visible','off'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); % Per saber si la capa seleccionada es la de sortida if c1 c=1; elseif c2 c=2; else c=3; end if (a ~= 0) set(handles.Num_neu,'Visible','on'); if (a == c) % Capa seleccionada=capa sortida -> Nº neurones fixat load('c:\matlabr12\work\datamlp.mat'); [m,n]=size(dat); nn=n-n_col_data; set(handles.Num_neu,'String',nn); set(handles.Transfer_xarxa,'Visible','on'); end else set(handles.Num_neu,'Visible','off'); end % -------------------------------------------------------------------- function Num_neu_Callback(h, eventdata, handles, varargin) % Es defineix el nº de neurones de la capa seleccionada. Encara havent % seleccionat la capa de sortida, qualsevol valor entrat es passara % per alt i es retornara al valor fixat segons targets. Premer ENTER % per seguir % Inicialitzacions n=str2num(get(h,'String')); a=get(handles.Capa,'Value'); c1=get(handles.Capa1,'Value');c2=get(handles.Capa2,'Value'); c3=get(handles.Capa3,'Value'); set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Transfer_xarxa,'Visible','off'); set(handles.Transfer_xarxa,'Value',1); set(handles.Ok_capa,'Visible','off'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); % Per saber si la capa seleccionada es la de sortida if c1 c=1; elseif c2 c=2; else c=3;

70

end if (a == c) % Capa seleccionada=capa sortida -> Nº neurones fixat load('c:\matlabr12\work\datamlp.mat'); [m,n]=size(dat); nn=n-n_col_data; set(handles.Num_neu,'String',nn); set(handles.Transfer_xarxa,'Visible','on'); elseif (n == []) % Capa seleccionada no es la de sortida -> Nº neurones minim=1 set(h,'String',1); set(handles.Transfer_xarxa,'Visible','on'); elseif (n >= 1) % Capa seleccionada no es la de sortida set(handles.Transfer_xarxa,'Visible','on'); else set(h,'String',1); end % -------------------------------------------------------------------- function Transfer_xarxa_Callback(h, eventdata, handles, varargin) % Eleccio de la funcio de transferencia associada a la capa activa % Inicialitzacions a=get(h,'Value'); set(handles.Trainf,'Visible','off');set(handles.Trainf,'Value',1); set(handles.Ok_capa,'Visible','off'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); if (a ~= 1) set(handles.Ok_capa,'Visible','on'); else set(h,'Value',1); set(handles.Ok_capa,'Visible','off'); end % -------------------------------------------------------------------- function Ok_capa_Callback(h, eventdata, handles, varargin) % DATAXARXAconte informacio relacionada amb la definicio de cada capa % Cal un cert control, ja que si la capa que es defineix ja ha estat % definida abans, es sobreescriura. I si totes les capes han estat ja % definides, s'activara un menu que permetra escollir la funcio per a % l'entrenament de la xarxa. Es un boto de confirmacio de capa global DATAXARXA; % Inicialitzacions a=get(handles.Capa,'Value'); b=str2num(get(handles.Num_neu,'String')); c=get(handles.Transfer_xarxa,'Value'); d1=get(handles.Capa1,'Value'); d2=get(handles.Capa2,'Value'); d3=get(handles.Capa3,'Value'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); % Per saber les capes de la xarxa if d1 d=1; elseif d2 d=2; elseif d3 d=3; else d=0; end if (exist('DATAXARXA') == 0)

71

DATAXARXA=[]; end if (a ~= 0) & (b >=1) & (c ~= 1) % La capa esta definida [m,n]=size(DATAXARXA); for i=1:m if (DATAXARXA(i,1) == a) % La capa definida existeix, cal borrar la que hi havia DATAXARXA=delsamps(DATAXARXA,i); [m,n]=size(DATAXARXA); end end % La capa no existeix, i cal guardar les dades en una taula que % s'usara despres en la creacio de la xarxa DATAXARXA(m+1,1)=a; DATAXARXA(m+1,2)=b; DATAXARXA(m+1,3)=c; set(handles.Num_neu,'Visible','off'); set(handles.Transfer_xarxa,'Visible','off'); set(h,'Visible','off'); end if (m+1 == d) % La capa que s'acaba de definir es la darrera, i per aixo ja es % pot passar a escollir la funcio d'entrenament assignada a la % xarxa set(handles.Trainf,'Visible','on'); set(handles.Trainf,'Value',1); set(handles.Capa,'Visible','off'); [m,n]=size(DATAXARXA); % Ordenar Dataxarxa per capes for i=1:m for j=1:n data(i,j)=0; end end for i=1:m j=1; while (DATAXARXA(j,1) ~= i) j=j+1; end data(i,:)=DATAXARXA(j,:); end DATAXARXA=data; end % -------------------------------------------------------------------- function Trainf_Callback(h, eventdata, handles, varargin) % S'assigna la funcio d'entrenament i s'activa un boto de confirmacio % per crear i inicialitzar la xarxa que s'ha definit % Inicialitzacions a=get(h,'Value'); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); if (a ~= 1) set(handles.Go_new,'Visible','on'); else set(h,'Value',1); set(handles.Go_new,'Visible','off'); end % -------------------------------------------------------------------- function Go_new_Callback(h, eventdata, handles, varargin) % La primera var. gloal informa de les capes de la xarxa, RED es la % xarxa creada i inicialitzada i RED2 tambe, pero s'usara per quan es % necessiti resetejar la xarxa

72

global DATAXARXA; global RED; global RED2; % Inicialitzacions a=get(handles.Nom_xarxa,'String'); b1=get(handles.Capa1,'Value'); b2=get(handles.Capa2,'Value'); b3=get(handles.Capa3,'Value'); c=get(handles.Trainf,'Value'); datax=DATAXARXA; set(handles.Epoch,'Visible','off');set(handles.Epoch,'Value',0); set(handles.Goal,'Visible','off');set(handles.Goal,'Value',0); set(handles.Epochn,'Visible','off');set(handles.Epochn,'String',0); set(handles.Goaln,'Visible','off');set(handles.Goaln,'String',0); set(handles.Fold,'Visible','off');set(handles.Fold,'Value',0); set(handles.text52,'Visible','off');set(handles.text52,'Value',0); set(handles.Ordre,'Visible','off');set(handles.Ordre,'String',1); set(handles.Leave1,'Visible','off');set(handles.Leave1,'Value',0); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); set(handles.Savedata,'Visible','off'); % Per saber les capes de la xarxa if b1 b=1; elseif b2 b=2; elseif b3 b=3; else b=0; end if (exist('c:\matlabr12\work\datamlp.mat') ~= 0) load('c:\matlabr12\work\datamlp.mat'); mat=dat;s=[];t=[];btf=[]; else mat=[];s=[];t=[];btf=[]; end if (mat ~= []) % Es defineixen les cadenes en el format adequat per a % crear la xarxa amb newff for i=1:b s=[s datax(i,2)]; % Funcio de transferencia de la capa switch (datax(i,3)) case 2 d={'tansig'}; case 3 d={'purelin'}; case 4 d={'logsig'}; end t=[t,d]; end % Funcio d'entrenament de la xarxa switch(c) case 2 btf='traingd'; case 3 btf='traingdm'; case 4 btf='traingda'; case 5 btf='traingdx'; case 6

73

btf='trainrp'; end % Crear i inicialitzar xarxa a=newff(mat_rang,s,t,btf); %aki es donde crea e inicializa la red con las variables q hemos %configurado anteriormente %mat_rang:es la matriz PR de maximos y minimos %necesaria para crear la red %btf:es la funcion de entrenamiento de la red %en 's' se define la func. de transferencia de la %capa a=init(a); RED=a; RED2=a; % Ja es pot passar a definir parametres de simulacio/validacio set(handles.Epoch,'Visible','on');set(handles.Epoch,'Value',0); %activo %editbox para poder configurar los parametros de %simulacion y validacion set(handles.Goal,'Visible','on'); set(handles.Goal,'Value',0); set(handles.Fold,'Visible','on'); set(handles.Fold,'Value',0); set(handles.Leave1,'Visible','on'); set(handles.Leave1,'Value',0); set(handles.porciento,'Visible','on'); set(handles.porciento,'Value',0); set(handles.bootstrap,'Visible','on'); set(handles.bootstrap,'Value',0); set(handles.porciento,'Visible','on'); %esto es para hacer visibles los menus %de validacion de la set(handles.bootstrap,'Visible','on'); %siguiente parte del formulario set(handles.text53,'Visible','on'); set(handles.epvtest,'Visible','on'); set(handles.text54,'Visible','on'); set(handles.conjboot,'Visible','on'); set(handles.text55,'Visible','on'); set(handles.pvectrain,'Visible','on'); end % -------------------------------------------------------------------- function Epoch_Callback(h, eventdata, handles, varargin) % Si s'opta per variar els epochs, apareixera una casella a omplir amb % el nº d'epochs desitjats. Si no es aixi, s'agafara 10 com a valor % per defecte. Es una casella opcional a=get(h,'Value'); if (a == 1) set(handles.Epochn,'Visible','on');set(handles.Epochn,'String',0); else set(h,'Value',0); set(handles.Epochn,'Visible','off');set(handles.Epochn,'String',0); end % -------------------------------------------------------------------- function Epochn_Callback(h, eventdata, handles, varargin) % Aqui s'assigna el nou valor, sempre i quan la cadena d'entrada sigui % de format numeric. Si conte altres caracters, es torna al valor per % defecte. Premer ENTER per seguir

74

a=get(handles.Epoch,'Value'); b=str2num(get(h,'String')); if (a == 1) if (b == []) set(h,'String',10); else nadena=0; end else set(h,'String',0); end % -------------------------------------------------------------------- function Goal_Callback(h, eventdata, handles, varargin) % Si s'opta per variar el goal, apareixera una casella a omplir amb el % goal desitjat. Si no es aixi, s'agafara 0 com a valor per defecte. % Es una casella opcional a=get(h,'Value'); if (a == 1) set(handles.Goaln,'Visible','on');set(handles.Goaln,'String',0); else set(h,'Value',0); set(handles.Goaln,'Visible','off');set(handles.Goaln,'String',0); end % -------------------------------------------------------------------- function Goaln_Callback(h, eventdata, handles, varargin) % Aqui s'assigna el nou valor, sempre i quan la cadena d'entrada sigui % de format numeric. Si conte altres caracters, es torna al valor per % defecte. Permer ENTER per seguir a=get(handles.Goal,'Value'); b=str2num(get(h,'String')); if (a == 1) if (b == []) set(h,'String',0); else nadena=0; end else set(h,'String',0); end % -------------------------------------------------------------------- function Fold_Callback(h, eventdata, handles, varargin) % Si s'escull fer validacio creuada, caldra determinar l'ordre de la % mateixa, entenent-lo com el nº de mostres a extreura de la matriu % de dades per testejar a=get(h,'Value'); set(handles.Leave1,'Value',0); set(handles.porciento,'Value',0); set(handles.bootstrap,'Value',0); if (a == 1) set(handles.text52,'Visible','on'); set(handles.Ordre,'Visible','on'); set(handles.Ordre,'String',1); set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0); set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off');set(handles.Ordre,'String',1); set(handles.Go_sim,'Visible','off');

75

set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function Ordre_Callback(h, eventdata, handles, varargin) % S'ha de tenir en compte que si l'ordre entrat no permet abarcar amb % exactitud tota la matriu de dades, s'haura de modificar el nº entrat % per l'usuari fins que aquest sigui multiple del nº de mesures. Ara % ja es podra simular la xarxa o be resetejar-la. Premer ENTER per % seguir a=str2num(get(h,'String')); set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); load('c:\matlabr12\work\datamlp.mat'); mat=dat; [m,n]=size(mat); if (a == []) set(h,'String',1); elseif (a < 1) set(h,'String',1); else nadena=0; end % Modificacio de l'ordre cas de no ser multiple while (mod(m,a) ~= 0) a=a-1; end set(h,'String',a); % -------------------------------------------------------------------- function Leave1_Callback(h, eventdata, handles, varargin) % Si s'ecull leave-1-out, 1 mesura sera per testejar i les altres per % entrenar. Ara ja es podra simular la xarxa o be resetejar-la a=get(h,'Value'); set(handles.Fold,'Value',0);set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off');set(handles.Ordre,'Value',1); set(handles.porciento,'Value',0); set(handles.bootstrap,'Value',0); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function Reset_net_Callback(h, eventdata, handles, varargin) % La xarxa pren el valor inicial, i no es comença l'entrenament amb la % xarxa amb valors previs global RED; global RED2; RED=RED2; % -------------------------------------------------------------------- function Go_sim_Callback(h, eventdata, handles, varargin) % Aqui les dades es prenen de forma que l'entrEnament esdeve un proces % iteratiu, d'acord amb el metode de validacio triat. %aki se simula directamente. Es donde usa los metodos de validacion en si

76

global RED; global RED2; global RES_SIM; global RES_REAL; global ACIERTOS; global rtglobal; global datos; global NN; %numero de sensores % Inicialitzacions resultstar=rtglobal; data=datos; a=RED; b=get(handles.Trainf,'Value'); %aqui coge la configuracion q hemos elegido para %entrenar y simular la red d=get(handles.Epoch,'Value');e=str2num(get(handles.Epochn,'String')); f=get(handles.Goal,'Value');g=str2num(get(handles.Goaln,'String')); h=get(handles.Fold,'Value');i=str2num(get(handles.Ordre,'String')); j=get(handles.Leave1,'Value'); porcien=get(handles.porciento,'Value'); %esto coge el valor del radio button para %ver q metodo esta boot=get(handles.bootstrap,'Value'); %seleccionado if (b ~= 1) % Si s'entra aqui es que la xarxa ha estat creada load('c:\matlabr12\work\datamlp.mat'); mat=dat; %mat toma el valor del archivo q contiene medidas y targets [m,n]=size(mat); for k=1:n_col_data % p conte dades p(:,k)=mat(:,k); %se almacenan todos los datos de mat en la matriz p end k=1; for l=n_col_data+1:n % t conte targets %se almacenan todos los targets en la matriz t t(:,k)=mat(:,l); k=k+1; end % Les matrius amb xarxes neurals es treballen transpostes respecte % als metodes estadistics pp=p'; %matriz de medidas traspuesta tt=t'; %matriz de targets traspuesta [m1,n1]=size(pp); %miramos y almacenamos el tamaño de las matrices anteriores [m2,n2]=size(tt); result_sim=[]; %inicializo vectores donde se guardatan resultados result_real=[]; if j % Leave-1-out for jar=1:n1 %desde 1 hasta las n1 medidas de cada sensor (ya q es la %matriz trspuesta pp) % Nou vector de test->Reset xarxa a=RED2; if d %aqui lo unico q hace es dar o bien los valores por defecto de %todos los parametros para entrenar y simular la red, o bien coger y asignar los q %ha metido el usuario % Variacio del nº d'epochs a.trainParam.epochs=e; %si pone el usuario un num de epocs se %coge el q mete else

77

a.trainParam.epochs=10; %si el usuario no mete ningun valor se %coge 10 por defecto end if f % Variacio del goal a.trainParam.goal=g; %idem, se coge el num de goals q pone el %usuario else a.trainParam.goal=0; %o bien se pone 0 por defecto si el usuario %no pone nada end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; key=1; entrena=[]; target=[]; for o=1:n1 if (o == jar) % Vector test leave=pp(:,o); tester=tt(:,o); end if (o ~= jar) % Vectors entrenament entrena(:,key)=pp(:,o); target(:,key)=tt(:,o); key=key+1; end end % Entrenament a=train(a,entrena,target); % Validacio y=sim(a,leave); result_sim=[result_sim y]; result_real=[result_real tester]; end end if h % Fold validation grupos=(m/i)-1; %Nº de vegades que cal iterar for jar=0:grupos % Nou vector de test->Reset xarxa a=RED2; if d % Variacio del nº d'epochs a.trainParam.epochs=e; else a.trainParam.epochs=10; end if f % Variacio del goal a.trainParam.goal=g; else a.trainParam.goal=0; end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5;

78

a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; indices=[]; for o=1:i % Vectors test fold_val1(:,o)=pp(:,(jar*i+o)); fold_val2(:,o)=tt(:,(jar*i+o)); indices=[indices (jar*i+o)]; end % Vectors entrenament ppp=delsamps(pp',indices)'; ttt=delsamps(tt',indices)'; % Entrenament a=train(a,ppp,ttt); % Validacio y=sim(a,fold_val1); result_sim=[result_sim y]; result_real=[result_real fold_val2]; end end %METODO POR PARTES if porcien %a partir de aki empieza el metodo por partes %ahora el usuario introducira el porcentaje de los vectores q quiere q sean de testeo con lo cual el porcentaje %restante sera para entrenar la red %el usuario introduce el nº de vectores de test %pvt=input('Introduzca porcentaje de vectores de testeo:') %la linea de arriba la sustituyo por: pvt=str2num(get(handles.epvtest,'String')); %introduzco porcentaje de vectores de testeo %pvt:porcentaje de vect de testeo %pve:porcentaje de vect de entrenamiento => no necesito esta variable %nvt:num de vect totales %nvtest:num de vect de validacion %nvtrain:num de vect de entrenamiento %nvt=70 %ponemos este numero de vect totales como ejemplo concreto [nvt c]=size(data) [fclas cclas]=size(resultstar) %cojo dimensiones de la matr de targets nvtest=(nvt*pvt)/100 %calculo num neto de vect a partir del porcentaje entrado %por el usuario nvtest=round(nvtest) %redondeo el num de vect de test en caso de decimales nvtrain=nvt-nvtest %una vez definido el num de vect de test keda definido el %num de vect de training n=nvt/nvtest; %n es el nº de iteraciones q tendra nuestro bucle nvtest=round(nvtest); %en caso de obtener decimales por nvt/nvtest redondeamos i=0; %inicializo contador de matriz de aciertos incr=0; %incremento de filas cada iteracion ini=1; %variable desde donde se cogeran los siguientes x vectores de testeo ini2=0; %variable desde donde empiezan a cogerse una parte de los vect de training %uso variables para poder ir desplazandome y conseguir las submatrices %correspondientes for i=1:n, %haremos esto tantas veces como iteraciones if i==2 %caso especial, en la 2º iter. ini2 se incrementa tan solo en 1

79

ini2=1 end %vectrain2=newdat([nvtest+1+incr:70],:); %esto es asi siempre %cambio la de arriba por esta: vectrain2=data([nvtest+1+incr:nvt],1:NN); %en vez de 70 es el num de filas o %mendidas totales %por tanto cambio todos los 70 por nvt if i==1 %caso especial, en la 1º iter. vectrain1=[0]; vectrain=vectrain2; % targetsob2=target([nvtest+1+incr:70],:); %la linea de arriba la modifico por: targetsob2=resultstar([nvtest+1+incr:nvt],:); targetsob=targetsob2; %A PARTIR DE AQUI MODIFICO LOS DAT POR DATA Y LOS TARGETS POR RESULTSTAR else vectrain1=data([ini2:incr],1:NN); %submatrices de vect de training vectrain=[vectrain1; vectrain2]; targetsob2=resultstar([nvtest+1+incr:nvt],:); targetsob1=resultstar([ini2:incr],:); targetsob=[targetsob1; targetsob2]; end vectest=data([ini:nvtest+incr],1:NN); %submatriz de vect de testeo newtarget=resultstar([ini:nvtest+incr],:); incr=incr+nvtest; %la proxima iteracion se incrementara ini=ini+nvtest; %me desplazo para coger los siguientes x vectores de simulacion ini2=ini2+nvtest; tvectest=vectest'; %transponemos las matrices para trabajar con mayor comodidad tvectrain=vectrain'; tnewtarget=newtarget'; %busco los parametros para crear la red neuronal minimum=min(vectest); %obtengo la matriz con los valores minimos de las medidas %de cada uno de los 6 sensores targetsobt=targetsob' %creo la red neuronal %la linea de arriba sobra puesto q la red ha sido creado anteriormente % Entrenamiento de la red %a continuacion para entrenar la red meto todo esto ya q estan todos los parametros q ha elegido el usuario: a=RED2; % asigna a 'a' la red creada anteriormente... if d %aqui lo unico q hace es dar o bien los valores por defecto de todos los parametros %para entrenar y simular la red, o bien coger y asignar los q ha metido el usuario % Variacio del nº d'epochs a.trainParam.epochs=e; %si pone el usuario un num de epocs se %coge el q mete else a.trainParam.epochs=10; %si el usuario no mete ningun valor se %coge 10 por defecto end

80

if f % Variacio del goal a.trainParam.goal=g; %idem, se coge el num de goals q pone el %usuario else a.trainParam.goal=0; %o bien se pone 0 por defecto si el usuario %no pone nada end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; net = train(a,tvectrain,targetsobt); %Puesto q el parametro a se ha hecho a partir %de la configuracion por parte del usuario % Simulacion de la red Y2 = sim(a,tvectest); Y2 %Comparo la salida con los targets o clases a las q tendrian q pertenecer las medidas error=0; errores=0; newY=round(Y2); %redondeo los nº a enteros para poder compararlos for q=1:nvtest for j=1:cclas if newY(j,q) == tnewtarget (j,q) %si coincide no hacemos nada else error=1; %si no coincide error=1 end end if error==1 errores=errores+1; %incrementamos nº errores end error=0; end Aciertos(i)=((nvt-errores)/nvt)*100 end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sum=0; k=1; num=max(size(Aciertos)); while k<num+1, sum=sum+Aciertos(k) k=k+1; end mediaciertos=sum/n; mediaciertos end %este end corresponde al if porcien... donde empieza el metodo... %METODO BOOTSTRAP if boot %a partir de aki empieza el metodo %numboot:nº de conjuntos bootstrap numboot=str2num(get(handles.conjboot,'String')) pve=str2num(get(handles.pvectrain,'String')); [nvt c]=size(data) %cojo automaticamente num de vect totales de la matriz dat [fclas cclas]=size(resultstar) %cojo dimensiones de la matr de targets nvent=(pve*nvt)/100 %calculo num neto de vect de entrenamiento

81

nvent=round(nvent) %redondeo num de vect de entrenam. cb=0; %inicializo contador del nº de conjuntos bootstrap, es decir del nº de iteraciones q tendran lugar %nvtest=nvt-nvent; %una vez definido el nº de vect de entrenam. keda definido el nº de vect de test. %Aqui s'inicia el bucle while cb<numboot, %controlo num de conjuntos bootstrap q se hacen cb=cb+1; %incremento nº de iteraciones ale=rand(1,nvent) %genero aleatoriamente num de filas de vect de entrenamiento %para posteriormente formar una matriz de vect de entrenamiento %Evidentemente la dimension de ale sera de 1xnºde vect de entrenam %Ale contiene los nº o indices de las filas seleccionadas aleatoriamente del %conjunto de vect totales. %Con lo cual ya podemos formar nuestra matriz de vect de entrenamiento(matent): ale=round(nvt*ale); ale=sort(ale); for t=1:nvent if ale(t)==0 ale(t)=1; end end %k=nvent; k=0; matent=data([ale],1:NN) %cogemos cada nº de fila y el resto de la fila hasta el final %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %Ahora tenemos q formar la matriz de vect de testeo o validacion. Dicha matriz %estara formada por todos los vect q no se encuentran en la matriz de vect de %entrenam. Para ello mediante el algoritmo %siguiente detectamos los q estan y los q no estan if ale(1)>1 for k=1:ale(1)-1 cont(k)=k; end end for i=2:nvent q=ale(i)-ale(i-1) if q>1 for j=1:q-1 k=k+1; cont(k)=ale(i-1)+j; end end end %por tanto nuestra matriz de vect de test sera: matval=data([cont],1:NN) %matriz de vect de testeo definitiva %ahora tenemos q definir 2 matrices de targets, una para los vect de %validacion y otra para los de entrenamiento matargv=resultstar([cont],:) %matriz de targets para los vect de validacion matarge=resultstar([ale],:) %matriz de targets para los vect de entrenamiento %ahora entreno y simulo tantas veces como conjuntos bootstrap ha definido el usuario:

82

tmatval=matval'; %transponemos las matrices para trabajar con mayor %comodidad tmatent=matent'; tmatargv=matargv'; tmatarge=matarge'; [res numtest]=size(tmatargv); if d %aqui lo unico q hace es dar o bien los valores por defecto de todos los parametros %para entrenar y simular la red, o bien coger y asignar los q ha %metido el usuario % Variacio del nº d'epochs RED2.trainParam.epochs=e; %si pone el usuario un num de epocs se %coge el q mete else RED2.trainParam.epochs=10; %si el usuario no mete ningun valor se %coge 10 por defecto end if f % Variacio del goal RED2.trainParam.goal=g; %idem, se coge el num de goals q pone el %usuario else RED2.trainParam.goal=0; %o bien se pone 0 por defecto si el %usuario no pone nada end % Introduccio dels altres parametres d'entrenament per defecte RED2.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; RED2.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; RED2.trainParam.max_perf_inc=1.04; RED2.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; RED2.trainParam.show=25;a.trainParam.time=inf; % Entrenamiento de la red net = train(RED2,tmatent,tmatarge); % Simulacion de la red Y2 = sim(RED2,tmatval) %Comparo la salida con los targets o clases a las q tendrian q pertenecer las medidas error=0; errores=0; [valor posicio]=max(Y2); for indx=1:numtest newY(posicio(indx),indx)=1; %redondeo los nº a enteros para poder compararlos end [res1 res2]=size(newY); if res1<res newY(res,1)=0; end tmatargv newY for qu=1:numtest for ju=1:cclas %desde 1 hasta el num de columnas q tenga la matr de targets if newY(ju,qu) == tmatargv (ju,qu) %si coincide no hacemos nada else error=1; %si no coincide error=1 end

83

end if error==1 errores=errores+1 %incrementamos nº errores end error=0; end Aciertos(cb)=((numtest-errores)/numtest)*100 end sum=0; w=1; num=max(size(Aciertos)); while w<num+1, sum=sum+Aciertos(w) w=w+1; end mediaciertos=sum/numboot; mediaciertos end %este end corresponde al primer if boot ..donde empieza el metodo bootstrap %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% set(handles.Savedata,'Visible','on'); end RED=RED2; RES_SIM=result_sim RES_REAL=result_real [m,n]=size(result_sim); % Cont es el nº de mesures que han estat simulades amb exit cont=0; for i=1:n if (round(result_sim(:,i)) == result_real(:,i)) cont=cont+1; end end % Index_encerts conte el % d'exit en la validacio de la xarxa index_encerts=100*cont/n; disp('Percentatge d´exit (%) : '); disp(index_encerts); ACIETOS=index_encerts; % -------------------------------------------------------------------- function Savedata_Callback(h, eventdata, handles, varargin) % Es guarden les dades mes importants de l'entrenament en un .mat.Les % dades estan contingudes en les variables globals. global RED2; global RES_SIM; global RES_REAL; global ACIERTOS; nombre_red=get(handles.Nom_xarxa,'String') net=RED2; mlp_simulado=RES_SIM; mlp_real=RES_REAL; mlp_encerts=ACIERTOS; if (mlp_simulado ~= []) [filename,pathname]=uiputfile('*.mat','Guardar resultats MLP'); if (filename ~= 0) nom=[pathname,filename]; save(nom,'nombre_red','net','mlp_simulado','mlp_real','mlp_encerts'); else nadena=0; end end

84

% -------------------------------------------------------------------- function Back_Callback(h, eventdata, handles, varargin) % Sortida del menu MLP, eliminiacio d'arxius temporals,retorn al menu % principal global MATRIZ_TOTAL; global DATAXARXA; global RED; global RED2; global RES_SIM; global RES_REAL; global ACIERTOS; MATRIZ_TOTAL=[]; DATAXARXA=[]; RED=[]; RED2=[]; RES_SIM=[]; RES_REAL=[]; ACIERTOS=0; if exist('c:\matlabr12\work\datamlp.mat') delete('c:\matlabr12\work\datamlp.mat'); end closereq; % -------------------------------------------------------------------- function varargout = Targets_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.Targets. disp('Targets Callback not implemented yet.') % -------------------------------------------------------------------- function varargout = Row_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.Row. disp('Row Callback not implemented yet.') % -------------------------------------------------------------------- function varargout = porciento_Callback(h, eventdata, handles, varargin) a=get(h,'Value'); set(handles.Fold,'Value',0);set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off');%set(handles.Ordre,'Value',1); set(handles.bootstrap,'Value',0); set(handles.Leave1,'Value',0); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function varargout = bootstrap_Callback(h, eventdata, handles, varargin) a=get(h,'Value'); set(handles.Leave1,'Value',0); set(handles.Fold,'Value',0); set(handles.porciento,'Value',0); %set(handles.conjboot,'Value',1); %set(handles.pvectrain,'Value',1); set(handles.conjboot,'String',''); %oju!! modificado

85

set(handles.pvectrain,'String',''); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function varargout = epvtest_Callback(h, eventdata, handles, varargin) pvt=str2num(get(handles.epvtest,'String')); % -------------------------------------------------------------------- function varargout = conjboot_Callback(h, eventdata, handles, varargin) numboot=str2num(get(handles.conjboot,'String')); % -------------------------------------------------------------------- function varargout = pvectrain_Callback(h, eventdata, handles, varargin) pve=str2num(get(handles.pvectrain,'String'));

86

-Funciones asociadas al menú LVQ function varargout = Menu_lvq(varargin) % Aquest GUI executa un analisi LVQ sobre les dades. Aqui es pot % % - Escollir entre les dades processades (cas d'haver-se fet un % processat previ) o be quedar-se amb les dades originals. Nomes % cal escollir entre una de les dues caselles inicials % % - Seleccionar l'arxiu que conte la matriu referents a les % categories % % - Extreure files o columnes de la matriu en cas de veure que % algun element de la matriu de dades es superflu. Cal premer % GO per continuar % % - Donar nom a la xarxa, escollir el nombre de neurones ocultes % de la xarxa, definir-ne el learning rate i finalment la funcio % d'aprenentatge. Premer GO per crear la xarxa % % - Opcionalment, es poden modificar dos parametres d'entrenament, % els epochs i el goal o objectiu final. Tambe caldra escollir % entre simular les dades dent leave-1-out o validacio creuada % % - La xarxa es podra reinicialitzar, i les dades de la simulacio % es podran guardar en un arxiu .mat warning off if nargin == 0 fig = openfig(mfilename,'reuse'); handles = guihandles(fig); guidata(fig, handles); if nargout > 0 varargout{1} = fig; end elseif ischar(varargin{1}) try [varargout{1:nargout}] = feval(varargin{:}); catch disp(lasterr); end end % -------------------------------------------------------------------- function Processed_data_Callback(h, eventdata, handles, varargin) % La variable global STATUS permet saber si les dades s'han processat % o no.En cas afirmatiu, aquesta casella es activable. global STATUS; % Inicialitzacions a=[]; set(handles.Original_data,'Value',0); set(handles.Go_extract,'Visible','off'); set(handles.Targets,'String',a); set(handles.Nom_xarxa,'Visible','off');

87

if (STATUS == 2) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Original_data_Callback(h, eventdata, handles, varargin) % La variable global STATUS permet saber si les dades s'han processat % o no.Tant si s'han processat com si no,aquesta casella es activable. global STATUS; % Inicialitzacions a=[]; set(handles.Processed_data,'Value',0); set(handles.Go_extract,'Visible','off'); set(handles.Targets,'String',a); set(handles.Nom_xarxa,'Visible','off'); if (STATUS == 2) | (STATUS == 1) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Targets_name_Callback(h, eventdata, handles, varargin) %coge de aki los targets % Es carrega l'arxiu de categories. Agafades les dades,ja no s'usa mes % aquest arxiu,les dades es prenen del fitxer. global MATRIZ_TOTAL; global NN; %Per saber on acaben dades i comencen classes global datlvq; global targlvq; % Inicialitzacions a=get(handles.Processed_data,'Value'); %mira si se han elegido los datos prepr o %los orig. b=get(handles.Original_data,'Value'); nomtar=[];resultstar=[];matriz_data_targets=[];n1=0; set(handles.Go_extract,'Visible','off'); set(handles.Nom_xarxa,'Visible','off'); if a load('c:\matlabr12\work\datapre.mat'); data=resultspre; datlvq=data; elseif b load('c:\matlabr12\work\dataini.mat'); data=resultsini; datlvq=data; else data=[]; end if (data ~= []) [filename,pathname]=uigetfile('*.*','Carregar fitxer targets'); if (filename ~= 0) nomtar=[pathname,filename];

88

resultstar=load(nomtar); targlvq=resultstar; c=exist('resultstar'); if (c == 0) %No es carrega cap arxiu nadena=0; else [m1,n1]=size(data); [m2,n2]=size(resultstar); if (m1 == m2) % La matriu conte dades i categories matriz_data_targets=[data resultstar]; set(handles.Go_extract,'Visible','on'); else nadena=0; end end else nadena=0; end else nadena=0; end set(handles.Targets,'String',nomtar); MATRIZ_TOTAL=matriz_data_targets; NN=n1; % -------------------------------------------------------------------- function Row_yes_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; % Inicialitzacions a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.Row_no,'Value',0);set(handles.Row,'String',c); set(handles.Row,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1) set(handles.Row,'Visible','on'); else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Row_no_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; % Inicialitzacions a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.Row_yes,'Value',0);set(handles.Row,'String',c); set(handles.Row,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1)

89

nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Col_yes_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; % Inicialitzacions a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.Col_no,'Value',0);set(handles.Col,'String',c); set(handles.Col,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1) set(handles.Col,'Visible','on'); else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Col_no_Callback(h, eventdata, handles, varargin) % Si la variable global existeix, es poden extreure dades. global MATRIZ_TOTAL; % Inicialitzacions a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); c=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.Col_yes,'Value',0);set(handles.Col,'String',c); set(handles.Col,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) if (get(h,'Value') == 1) nadena=0; else set(h,'Value',0); end else set(h,'Value',0); end % -------------------------------------------------------------------- function Go_extract_Callback(h, eventdata, handles, varargin) % Si la matriu dades-targets existeix, s'extreuran les dades que es % desitgin. Un cop extretes, es guardaran en un arxiu .mat temporal i % s'activaran caselles per crear la xarxa global MATRIZ_TOTAL; global NN; %Columnes arxiu dades (p.e. nº sensors) a=get(handles.Processed_data,'Value'); b=get(handles.Original_data,'Value'); filas=str2num(get(handles.Row,'String'));

90

columnas=str2num(get(handles.Col,'String')); f=[]; set(handles.Nom_xarxa,'Visible','off'); set(handles.L_rate,'Visible','off');set(handles.L_rate,'String',0.01); set(handles.Num_neu,'Visible','off');set(handles.Num_neu,'String',1); set(handles.Learnf,'Visible','off');set(handles.Learnf,'Value',1); set(handles.Go_new,'Visible','off'); set(handles.Savedata,'Visible','off'); mat=MATRIZ_TOTAL; if (a | b) & (mat ~= []) data=mat; else data=[]; end if (data ~= []) dat=data; % Cont2 sera el nº de columnes de dades de la matriu un cop feta % l'extraccio contador2=NN; if (filas ~= []) [m,n]=size(filas); for i=1:n-1 for j=i+1:n if (filas(i) == filas(j)) % Fila a extreure repetida filas(j)=1e6; end end end for i=1:n if (filas(i) <= 0) %No existeix fila 0 en Matlab filas(i)=1e6; end if (filas(i) > n) % No existeix aquesta fila en la matriu filas(i)=1e6; end end dat=delsamps(dat,filas); end if (columnas ~=[]) [m,n]=size(columnas); for i=1:n-1 for j=i+1:n if (columnas(i) == columnas(j)) % Columna a extreure repetida columnas(j)=1e6; end end end for i=1:n if (columnas(i) <= 0) %No existeix columna 0 en Matlab columnas(i)=1e6; end if (columnas(i) > NN) %No es suprimeixen columnes de classes columnas(i)=1e6; end end contador=0; if (columnas ~= []) for i=1:length(columnas) if (columnas(i) ~= 1e6) % Si s'incrementa contador, % es que la columna es suprimeix contador=contador+1;

91

end end end contador2=NN-contador; dat=delsamps(dat',columnas)'; end if (contador2 > 0) for i=1:contador2 % Definicio de la matriu de rangs (util per crear xarxa) rangmax(i)=max(dat(:,i));rangmin(i)=min(dat(:,i)); mat_rang(i,:)=[rangmin(i) rangmax(i)]; end n_col_data=contador2; else mat_rang=[];n_col_data=0; end set(handles.Nom_xarxa,'Visible','on'); set(handles.Nom_xarxa,'String',f); else dat=[];mat_rang=[];n_col_data=0; end % Creacio d'arxiu temporal amb les dades mes importants per fer LVQ save('c:\matlabr12\work\datalvq.mat','data','dat','mat_rang','n_col_data'); % -------------------------------------------------------------------- function Nom_xarxa_Callback(h, eventdata, handles, varargin) % La variable global conte informacio de cada capa de la xarxa, i es % reseteja cada cop que introduim un nou nom a la xarxa. Premer ENTER % per seguir creant la xarxa. % Inicialitzacions a=get(h,'String'); b=[]; set(handles.Num_neu,'Visible','off');set(handles.Num_neu,'String',1); set(handles.L_rate,'Visible','off');set(handles.L_rate,'String',0.01); set(handles.Learnf,'Visible','off');set(handles.Learnf,'Value',1); set(handles.Go_new,'Visible','off'); set(handles.Reset_net,'Visible','off'); if (exist('c:\matlabr12\work\datalvq.mat') ~= 0) load('c:\matlabr12\work\datalvq.mat'); if (a ~= []) & (dat ~= []) & (mat_rang ~= []) & (n_col_data ~= 0) % Un cop creada la matriu data-targets i donat un nom, ja % es poden definir altres parametres. set(handles.Num_neu,'Visible','on'); else set(h,'String',b); end end % -------------------------------------------------------------------- function Num_neu_Callback(h, eventdata, handles, varargin) % Aqui s'introdueix el nº de neurones ocultes. Premer ENTER per seguir % Si l'usuari no entra enters, s'assigna un valor per defecte % Inicialitzacions n=str2num(get(h,'String')); set(handles.L_rate,'Visible','off');set(handles.L_rate,'String',0.01); set(handles.Learnf,'Visible','off');set(handles.Learnf,'Value',1); set(handles.Go_new,'Visible','off'); set(handles.Reset_net,'Visible','off'); if (n == []) | (n < 1) set(h,'String',1); set(handles.L_rate,'Visible','off'); else set(handles.L_rate,'Visible','on'); end

92

% -------------------------------------------------------------------- function L_rate_Callback(h, eventdata, handles, varargin) % Aqui s'introdueix el learning rate. Premer ENTER per seguir. Si no % s'entren enters, s'assginen valors per defecte % Inicialitzacions a=str2num(get(h,'String')); set(handles.Learnf,'Visible','off');set(handles.Learnf,'Value',1); set(handles.Go_new,'Visible','off'); set(handles.Reset_net,'Visible','off'); if (a == []) set(h,'Value',0.01); set(handles.Learnf,'Visible','off'); else set(handles.Learnf,'Visible','on'); end % -------------------------------------------------------------------- function Learnf_Callback(h, eventdata, handles, varargin) % Eleccio de la funcio d'aprenentatge. Si tot el proces s'ha realitzat % correctament, es passara a activar el boto que permetra ja no nomes % crear sino tambe inicialitzar la xarxa % Inicialitzacions a=get(h,'Value'); set(handles.Go_new,'Visible','off'); set(handles.Reset_net,'Visible','off'); if (a == 1) set(h,'Value',1); set(handles.Go_new,'Visible','off'); else set(handles.Go_new,'Visible','on'); end % -------------------------------------------------------------------- function Go_new_Callback(h, eventdata, handles, varargin) % RED es la xarxa creada i inicialitzada i RED2 tambe, pero s'usara % quan es necessiti resetejar la xarxa global RED; global RED2; % Inicialitzacions a=get(handles.Nom_xarxa,'String'); b=str2num(get(handles.Num_neu,'String')); c=str2num(get(handles.L_rate,'String')); d=get(handles.Learnf,'Value'); set(handles.Epoch,'Visible','off');set(handles.Epoch,'Value',0); set(handles.Goal,'Visible','off');set(handles.Goal,'Value',0); set(handles.Epochn,'Visible','off');set(handles.Epochn,'String',0); set(handles.Goaln,'Visible','off');set(handles.Goaln,'String',0); set(handles.Fold,'Visible','off');set(handles.Fold,'Value',0); set(handles.text52,'Visible','off');set(handles.text52,'Value',0); set(handles.Ordre,'Visible','off');set(handles.Ordre,'String',1); set(handles.Leave1,'Visible','off');set(handles.Leave1,'Value',0); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); set(handles.Savedata,'Visible','off'); set(handles.perpartsl,'Visible','on'); %a partir de aqui modificado set(handles.cvt,'Visible','on'); set(handles.pvtl,'Visible','on'); set(handles.Bstrapl,'Visible','on'); set(handles.text56,'Visible','on'); set(handles.ncbootl,'Visible','on'); set(handles.text57,'Visible','on'); set(handles.pvtrainl,'Visible','on');

93

if (exist('c:\matlabr12\work\datalvq.mat') ~= 0) load('c:\matlabr12\work\datalvq.mat'); mat=dat;pc=[];lr=[];lf=[]; else mat=[];pc=[];lr=[];lf=[]; end if (mat ~= []) [m,n]=size(mat); % Assignacio de pesos a cada entrada de la xarxa. Per defecte % totes les entrades es ponderaran igual nn=n-n_col_data; valor=1/nn; for i=1:nn pc(i)=valor; end % Learning rate lr=c; % Funcio d'aprenentatge de la xarxa switch(d) case 2 lf='learnlv1'; case 3 lf='learnlv2'; end % Crear i inicialitzar xarxa a=newlvq(mat_rang,b,pc,lr,lf); a=init(a); RED=a; RED2=RED; % Ja es pot passar a definir parametres de simulacio/validacio set(handles.Epoch,'Visible','on');set(handles.Epoch,'Value',0); set(handles.Goal,'Visible','on');set(handles.Goal,'Value',0); set(handles.Fold,'Visible','on');set(handles.Fold,'Value',0); set(handles.Leave1,'Visible','on');set(handles.Leave1,'Value',0); end % -------------------------------------------------------------------- function Epoch_Callback(h, eventdata, handles, varargin) % Si s'opta per variar els epochs, apareixera una casella a omplir amb % el nº d'epochs desitjats. Si no es aixi, s'agafara 10 com a valor % per defecte. Es una casella opcional a=get(h,'Value'); if (a == 1) set(handles.Epochn,'Visible','on');set(handles.Epochn,'String',0); else set(h,'Value',0); set(handles.Epochn,'Visible','off');set(handles.Epochn,'String',0); end % -------------------------------------------------------------------- function Epochn_Callback(h, eventdata, handles, varargin) % Aqui s'assigna el nou valor, sempre i quan la cadena d'entrada sigui % de format numeric. Si conte altres caracters, es torna al valor per % defecte. Premer ENTER per seguir a=get(handles.Epoch,'Value'); b=str2num(get(h,'String')); if (a == 1) if (b == []) set(h,'String',10); else

94

nadena=0; end else set(h,'String',0); end % -------------------------------------------------------------------- function Goal_Callback(h, eventdata, handles, varargin) % Si s'opta per variar el goal, apareixera una casella a omplir amb el % goal desitjat. Si no es aixi, s'agafara 0 com a valor per defecte. % Es una casella opcional a=get(h,'Value'); if (a == 1) set(handles.Goaln,'Visible','on');set(handles.Goaln,'String',0); else set(h,'Value',0); set(handles.Goaln,'Visible','off');set(handles.Goaln,'String',0); end % -------------------------------------------------------------------- function Goaln_Callback(h, eventdata, handles, varargin) % Aqui s'assigna el nou valor, sempre i quan la cadena d'entrada sigui % de format numeric. Si conte altres caracters, es torna al valor per % defecte. Permer ENTER per seguir a=get(handles.Goal,'Value'); b=str2num(get(h,'String')); if (a == 1) if (b == []) set(h,'String',0); else nadena=0; end else set(h,'String',0); end % -------------------------------------------------------------------- function Fold_Callback(h, eventdata, handles, varargin) % Si s'escull fer validacio creuada, caldra determinar l'ordre de la % mateixa, entenent-lo com el nº de mostres a extreura de la matriu % de dades per testejar a=get(h,'Value'); set(handles.Leave1,'Value',0); set(handles.perpartsl,'Value',0); set(handles.Bstrapl,'Value',0); if (a == 1) set(handles.text52,'Visible','on'); set(handles.Ordre,'Visible','on');set(handles.Ordre,'String',1); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%a partir de aki mio set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% else set(h,'Value',0); set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off');set(handles.Ordre,'String',1); set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function Ordre_Callback(h, eventdata, handles, varargin) % S'ha de tenir en compte que si l'ordre entrat no permet abarcar amb % exactitud tota la matriu de dades, s'haura de modificar el nº entrat % per l'usuari fins que aquest sigui multiple del nº de mesures. Ara

95

% ja es podra simular la xarxa o be resetejar-la. Premer ENTER per % seguir a=str2num(get(h,'String')); set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); load('c:\matlabr12\work\datalvq.mat'); mat=dat; [m,n]=size(mat); if (a == []) set(h,'String',1); elseif (a < 1) set(h,'String',1); else nadena=0; end % Modificacio de l'ordre cas de no ser multiple while (mod(m,a) ~= 0) a=a-1; end set(h,'String',a); % -------------------------------------------------------------------- function Leave1_Callback(h, eventdata, handles, varargin) % Si s'ecull leave-1-out, 1 mesura sera per testejar i les altres per % entrenar. Ara ja es podra simular la xarxa o be resetejar-la a=get(h,'Value'); set(handles.Fold,'Value',0);set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off');set(handles.Ordre,'Value',1); set(handles.perpartsl,'Value',0); set(handles.Bstrapl,'Value',0); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function Reset_net_Callback(h, eventdata, handles, varargin) % La xarxa pren el valor inicial, i no es comença l'entrenament amb la % xarxa amb valors previs global RED; global RED2; RED=RED2; % -------------------------------------------------------------------- function Go_sim_Callback(h, eventdata, handles, varargin) % Aqui les dades es prenen de forma que l'enternament esdeve un proces % iteratiu, d'acord amb el metode de validacio triat. global RED; global RED2 global RES_SIM; global RES_REAL; global ACIERTOS; global datlvq; %creo var globales auxiliares global targlvq; global NN % Inicialitzacions

96

a=RED; b=get(handles.Learnf,'Value'); d=get(handles.Epoch,'Value');e=str2num(get(handles.Epochn,'String')); f=get(handles.Goal,'Value');g=str2num(get(handles.Goaln,'String')); h=get(handles.Fold,'Value');i=str2num(get(handles.Ordre,'String')); j=get(handles.Leave1,'Value'); parts=get(handles.perpartsl,'Value'); %mira si ha escogido el met. perparts, el radio button boot=get(handles.Bstrapl,'Value'); %mira si ha escogido el radio button de bootstrap data=datlvq; resultstar=targlvq; if (b ~= 1) % Si s'entra aqui es que la xarxa ha estat creada load('c:\matlabr12\work\datalvq.mat'); mat=dat; [m,n]=size(mat); for k=1:n_col_data % p conte dades p(:,k)=mat(:,k); end k=1; for l=n_col_data+1:n % t conte targets t(:,k)=mat(:,l); k=k+1; end % Les matrius amb xarxes neurals es treballen transpostes respecte % als metodes estadistics pp=p'; tt=t'; [m1,n1]=size(pp); [m2,n2]=size(tt); result_sim=[]; result_real=[]; if j % Leave-1-out for jar=1:n1 % Nou vector de test->Reset xarxa a=RED2; if d % Variacio del nº d'epochs a.trainParam.epochs=e; else a.trainParam.epochs=10; end if f % Variacio del goal a.trainParam.goal=g; else a.trainParam.goal=0; end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; key=1; entrena=[]; target=[]; for o=1:n1 if (o == jar) % Vector test leave=pp(:,o);

97

tester=tt(:,o); end if (o ~= jar) % Vectors entrenament entrena(:,key)=pp(:,o); target(:,key)=tt(:,o); key=key+1; end end % Entrenament a=train(a,entrena,target); % Validacio y=sim(a,leave); result_sim=[result_sim y]; result_real=[result_real tester]; end end if h % Fold validation grupos=(m/i)-1; %Nº de vegades que cal iterar for jar=0:grupos % Nou vector de test->Reset xarxa a=RED2; if d % Variacio del nº d'epochs a.trainParam.epochs=e; else a.trainParam.epochs=10; end if f % Variacio del goal a.trainParam.goal=g; else a.trainParam.goal=0; end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; indices=[]; for o=1:i % Vectors test fold_val1(:,o)=pp(:,(jar*i+o)); fold_val2(:,o)=tt(:,(jar*i+o)); indices=[indices (jar*i+o)]; end % Vectors entrenament ppp=delsamps(pp',indices)'; ttt=delsamps(tt',indices)'; % Entrenament a=train(a,ppp,ttt); % Validacio y=sim(a,fold_val1); result_sim=[result_sim y]; result_real=[result_real fold_val2]; end end %%%%%%%%%%%%%%%%%AQUI EMPIEZA PERPARTS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! if parts %a partir de aki empieza el metodo por partes %ahora el usuario introducira el porcentaje de los vectores q kiere q sean %de testeo con lo cual el porcentaje %restante sera para entrenar la red %el usuario introduce el nº de vectores de test

98

%la linea de arriba la sustituyo por: pvt=str2num(get(handles.pvtl,'String')) %introduzco porcentaje de vectores de testeo %pvt:porcentaje de vect de testeo %pve:porcentaje de vect de entrenamiento => no necesito esta variable %nvt:num de vect totales %nvtest:num de vect de validacion %nvtrain:num de vect de entrenamiento %nvt=70 %ponemos este numero de vect totales como ejemplo concreto [nvt c]=size(data) [fclas cclas]=size(resultstar) %cojo dimensiones de la matr de targets nvtest=(nvt*pvt)/100 %calculo num neto de vect a partir del porcentaje entrado %por el usuario nvtest=round(nvtest) %redondeo el num de vect de test en caso de decimales nvtrain=nvt-nvtest %una vez definido el num de vect de test keda definido el %num de vect de training %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% n=nvt/nvtest; %n es el nº de iteraciones q tendra nuestro bucle nvtest=round(nvtest); %en caso de obtener decimales por nvt/nvtest redondeamos i=0; %inicializo contador de matriz de aciertos incr=0; %incremento de filas cada iteracion ini=1; %variable desde donde se cogeran los siguientes x vectores de testeo ini2=0; %variable desde donde empiezan a cogerse una parte de los vect de %training %uso variables para poder ir desplazandome y conseguir las submatrices correspondientes for i=1:n, %haremos esto tantas veces como iteraciones if i==2 %caso especial, en la 2º iter. ini2 se incrementa tan solo en 1 ini2=1 end %vectrain2=newdat([nvtest+1+incr:70],:); %esto es asi siempre %cambio la de arriba por esta: vectrain2=data([nvtest+1+incr:nvt],1:NN); %en vez de 70 es el num de filas o %medidas totales %por tanto cambio todos los 70 por nvt if i==1 %caso especial, en la 1º iter. vectrain1=[0]; vectrain=vectrain2; % targetsob2=target([nvtest+1+incr:70],:); %la linea de arriba la modifico por: targetsob2=resultstar([nvtest+1+incr:nvt],:); targetsob=targetsob2; else vectrain1=data([ini2:incr],1:NN); %submatrices de vect de %training vectrain=[vectrain1; vectrain2]; targetsob2=resultstar([nvtest+1+incr:nvt],:); targetsob1=resultstar([ini2:incr],:); targetsob=[targetsob1; targetsob2];

99

end vectest=data([ini:nvtest+incr],1:NN); %submatriz de vect de testeo newtarget=resultstar([ini:nvtest+incr],:); incr=incr+nvtest; %la proxima iteracion se incrementara ini=ini+nvtest; %me desplazo para coger los siguientes x vectores de simulacion ini2=ini2+nvtest; tvectest=vectest'; %transponemos las matrices para trabajar con mayor comodidad tvectrain=vectrain'; tnewtarget=newtarget'; % Entrenamiento de la red %a continuacion para entrenar la red meto todo esto ya q estan todos los parametros q ha elegido %el usuario: a=RED2; if d %aki lo unico q hace es dar o bien los valores por defecto de todos los parametros %para entrenar y simular la red, o bien coger y asignar los q ha metido el usuario % Variacio del nº d'epochs a.trainParam.epochs=e; %si pone el usuario un num de epocs se coge el q mete else a.trainParam.epochs=10; %si el usuario no mete ningun valor se coge 10 por defecto end if f % Variacio del goal a.trainParam.goal=g; %idem, se coge el num de goals q pone el usuario else a.trainParam.goal=0; %o bien se pone 0 por defecto si el usuario no pone nada end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05; a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% net = train(a,tvectrain,targetsobt); %PUESTO Q el parametro a se ha hecho a partir de la configuracion %por parte del usuario % Simulacion de la red Y2 = sim(a,tvectest); %Comparo la salida con los targets o clases a las q tendrian q pertenecer las medidas error=0; errores=0; newY=round(Y2); %redondeo los nº a enteros para poder compararlos for q=1:nvtest for j=1:cclas if newY(j,q) == tnewtarget (j,q) %si coincide no hacemos nada else

100

error=1; %si no coincide error=1 end end if error==1 errores=errores+1; %incrementamos nº errores end error=0; end Aciertos(i)=((nvt-errores)/nvt)*100 end %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% sum=0; k=1; num=max(size(Aciertos)); while k<num+1, sum=sum+Aciertos(k) k=k+1; end mediaciertos=sum/n; mediaciertos end %este end corresponde al if porcien... donde empieza el metodo... %%%%%%%%%%%%%%%%%AQUI ACABA PER PARTS!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %METODO BOOTSTRAP if boot %a partir de aki empieza el metodo %numboot:nº de conjuntos bootstrap %numboot=input('Indique el nº de conjuntos de bootstrap que desea emplear:') %la linea de arriba la sustituyo por esta siguiente para hacer la interficie numboot=str2num(get(handles.ncbootl,'String')) pve=str2num(get(handles.pvtrainl,'String')); [nvt c]=size(data) %cojo automaticamente num de vect totales de la matriz dat [fclas cclas]=size(resultstar) %cojo dimensiones de la matr de targets nvent=(pve*nvt)/100 %calculo num neto de vect de entrenamiento nvent=round(nvent) %redondeo num de vect de entrenam. cb=0; %inicializo contador del nº de conjuntos bootstrap, es decir del nº de %iteraciones q tendran lugar %nvtest=nvt-nvent; %una vez definido el nº de vect de entrenam. keda definido el nº de vect de test. %Aqui s'inicia el bucle while cb<numboot, %controlo num de conjuntos bootstrap q se hacen cb=cb+1; %incremento nº de iteraciones ale=rand(1,nvent) %genero aleatoriamente num de filas de vect de entrenamiento %para posteriormente formar una matriz de vect de entrenamiento %Evidentemente la dimension de ale sera de 1xnºde vect de entrenam %Ale contiene los nº o indices de las filas seleccionadas aleatoriamente del %conjunto de vect totales. %Con lo cual ya podemos formar nuestra matriz de vect de entrenamiento(matent): ale=round(nvt*ale); ale=sort(ale); for t=1:nvent if ale(t)==0 ale(t)=1; end end %k=nvent; k=0;

101

matent=data([ale],1:NN) %cogemos cada nº de fila y el resto de la fila hasta el final %Ahora tenemos q formar la matriz de vect de testeo o validacion. Dicha matriz %estara formada por todos los vect q no se encuentran en la matriz de vect de %entrenam. Para ello mediante el algoritmo siguiente detectamos los q estan y los %q no estan if ale(1)>1 for k=1:ale(1)-1 cont(k)=k; end end for i=2:nvent q=ale(i)-ale(i-1) if q>1 for j=1:q-1 k=k+1; cont(k)=ale(i-1)+j; end end end %por tanto nuestra matriz de vect de test sera: matval=data([cont],1:NN) %matriz de vect de testeo definitiva %ahora tenemos q definir 2 matrices de targets, una para los vect de %validacion y otra para los de entrenamiento matargv=resultstar([cont],:) %matriz de targets para los vect de validacion matarge=resultstar([ale],:) %matriz de targets para los vect de entrenamiento %ahora entreno y simulo tantas veces como conjuntos bootstrap ha definido el %usuario: tmatval=matval'; %transponemos las matrices para trabajar con mayor comodidad tmatent=matent'; tmatargv=matargv'; tmatarge=matarge'; [res numtest]=size(tmatargv); a=RED2; if d %aki lo unico q hace es dar o bien los valores por defecto de todos los parametros %para entrenar y simular la red, o bien coger y asignar los q ha %metido el usuario % Variacio del nº d'epochs a.trainParam.epochs=e; %si pone el usuario un num de epocs se %coge el q mete else a.trainParam.epochs=10; %si el usuario no mete ningun valor se %coge 10 por defecto end if f % Variacio del goal a.trainParam.goal=g; %idem, se coge el num de goals q pone el %usuario else a.trainParam.goal=0; %o bien se pone 0 por defecto si el usuario %no pone nada end % Introduccio dels altres parametres d'entrenament per defecte a.trainParam.lr=0.01;a.trainParam.lr_inc=1.05;

102

a.trainParam.lr_dec=0.7;a.trainParam.max_fail=5; a.trainParam.max_perf_inc=1.04; a.trainParam.mc=0.9;a.trainParam.min_grad=1e-10; a.trainParam.show=25;a.trainParam.time=inf; % Entrenamiento de la red net = train(RED2,tmatent,tmatarge); % Simulacion de la red Y2 = sim(RED2,tmatval) %Comparo la salida con los targets o clases a las q tendrian q pertenecer las medidas error=0; errores=0; [valor posicio]=max(Y2); for indx=1:numtest newY(posicio(indx),indx)=1; %redondeo los nº a enteros para poder compararlos end [res1 res2]=size(newY); if res1<res newY(res,1)=0; end tmatargv newY for qu=1:numtest for ju=1:cclas %desde 1 hasta el num de columnas q tenga la matr de targets if newY(ju,qu) == tmatargv (ju,qu) %si coincide no hacemos nada else error=1; %si no coincide error=1 end end if error==1 errores=errores+1 %incrementamos nº errores end error=0; end Aciertos(cb)=((numtest-errores)/numtest)*100 end sum=0; w=1; num=max(size(Aciertos)); while w<num+1, sum=sum+Aciertos(w) w=w+1; end mediaciertos=sum/numboot; mediaciertos end %este end corresponde al primer if boot ..... donde empieza el metodo bootstrap %%%%%%%%%%%%%%%AQUI ACABA BOOTSTRAP!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! set(handles.Savedata,'Visible','on'); end RED=RED2; RES_SIM=result_sim RES_REAL=result_real % Cont es el nº de mesures que han estat simulades amb exit cont=0; for i=1:n

103

if (round(result_sim(:,i)) == result_real(:,i)) cont=cont+1; end end % Index_encerts conte el % d'exit en la validacio de la xarxa index_encerts=100*cont/n; disp('Percentatge d´exit (%) : '); disp(index_encerts); ACIETOS=index_encerts; % -------------------------------------------------------------------- function Savedata_Callback(h, eventdata, handles, varargin) % Es guarden les dades mes importants de l'entrenament en un .mat.Les % dades estan contingudes en les variables globals. global RED2; global RES_SIM; global RES_REAL; global ACIERTOS; nombre_red=get(handles.Nom_xarxa,'String') net=RED2; lvq_simulado=RES_SIM; lvq_real=RES_REAL; lvq_encerts=ACIERTOS; if (lvq_simulado ~= []) [filename,pathname]=uiputfile('*.mat','Guardar resultats LVQ'); if (filename ~= 0) nom=[pathname,filename]; save(nom,'nombre_red','net','lvq_simulado','lvq_real','lvq_encerts'); else nadena=0; end end % -------------------------------------------------------------------- function Back_Callback(h, eventdata, handles, varargin) % Sortida del menu LVQ, eliminiacio d'arxius temporals,retorn al menu % principal global MATRIZ_TOTAL; global RED; global RED2; global RES_SIM; global RES_REAL; global ACIERTOS; MATRIZ_TOTAL=[]; RED=[]; RED2=[]; RES_SIM=[]; RES_REAL=[]; ACIERTOS=0; if exist('c:\matlabr12\work\datalvq.mat') delete('c:\matlabr12\work\datalvq.mat'); end closereq; % -------------------------------------------------------------------- function varargout = perpartsl_Callback(h, eventdata, handles, varargin) set(handles.Leave1,'Value',0); set(handles.Fold,'Value',0); set(handles.Bstrapl,'Value',0); set(handles.text52,'Visible','off');

104

set(handles.Ordre,'Visible','off'); set(handles.Ordre,'Value',1); a=get(h,'Value'); if (a == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function varargout = Bstrapl_Callback(h, eventdata, handles, varargin) set(handles.Leave1,'Value',0); set(handles.Fold,'Value',0); set(handles.perpartsl,'Value',0); set(handles.text52,'Visible','off'); set(handles.Ordre,'Visible','off'); set(handles.Ordre,'Value',1); bo=get(h,'Value'); if (bo == 1) set(handles.Go_sim,'Visible','on'); set(handles.Reset_net,'Visible','on'); else set(h,'Value',0);set(handles.Go_sim,'Visible','off'); set(handles.Reset_net,'Visible','off'); end % -------------------------------------------------------------------- function varargout = ncbootl_Callback(h, eventdata, handles, varargin) numboot=str2num(get(handles.ncbootl,'String')); % -------------------------------------------------------------------- function varargout = pvtrainl_Callback(h, eventdata, handles, varargin) pve=str2num(get(handles.pvtrainl,'String')); %----------------------------------------------------------------------- function varargout = pvtl_Callback(h, eventdata, handles, varargin) pvt=str2num(get(handles.perpartsl,'String')); %introduzco porcentaje de vectores de testeo

105

-Funciones asociadas al menú Gaselctr function varargout = gaselnew(varargin) % GASELNEW Application M-file for gaselnew.fig % FIG = GASELNEW launch gaselnew GUI. % GASELNEW('callback_name', ...) invoke the named callback. % Last Modified by GUIDE v2.0 19-Jan-2004 18:46:28 if nargin == 0 % LAUNCH GUI fig = openfig(mfilename,'reuse'); % Use system color scheme for figure: set(fig,'Color',get(0,'defaultUicontrolBackgroundColor')); % Generate a structure of handles to pass to callbacks, and store it. handles = guihandles(fig); guidata(fig, handles); if nargout > 0 varargout{1} = fig; end elseif ischar(varargin{1}) % INVOKE NAMED SUBFUNCTION OR CALLBACK try [varargout{1:nargout}] = feval(varargin{:}); % FEVAL switchyard catch disp(lasterr); end end %| ABOUT CALLBACKS: %| GUIDE automatically appends subfunction prototypes to this file, and %| sets objects' callback properties to call them through the FEVAL %| switchyard above. This comment describes that mechanism. %| %| Each callback subfunction declaration has the following form: %| <SUBFUNCTION_NAME>(H, EVENTDATA, HANDLES, VARARGIN) %| %| The subfunction name is composed using the object's Tag and the %| callback type separated by '_', e.g. 'slider2_Callback', %| 'figure1_CloseRequestFcn', 'axis1_ButtondownFcn'. %| %| H is the callback object's handle (obtained using GCBO). %| %| EVENTDATA is empty, but reserved for future use. %| %| HANDLES is a structure containing handles of components in GUI using %| tags as fieldnames, e.g. handles.figure1, handles.slider2. This %| structure is created at GUI startup using GUIHANDLES and stored in %| the figure's application data using GUIDATA. A copy of the structure %| is passed to each callback. You can store additional information in %| this structure at GUI startup, and you can change the structure %| during callbacks. Call guidata(h, handles) after changing your %| copy to replace the stored original so that subsequent callbacks see %| the updates. Type "help guihandles" and "help guidata" for more

106

%| information. %| %| VARARGIN contains any extra arguments you have passed to the %| callback. Specify the extra arguments by editing the callback %| property in the inspector. By default, GUIDE sets the property to: %| <MFILENAME>('<SUBFUNCTION_NAME>', gcbo, [], guidata(gcbo)) %| Add any extra arguments after the last argument, before the final %| closing parenthesis. function varargout = dator_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.dator. global rtglobal; %declaramos estas var globales para poder usarlas global resultsini; global x; global y; load('c:\matlabr12\work\dataini.mat'); set(handles.datpre,'Value',0); %exclusion mutua para los 2 radio buttons x=resultsini; y=rtglobal; % los targets los tiene q cargar el usuario % -------------------------------------------------------------------- function varargout = datpre_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.datpre. global rtglobal; %declaramos estas var globales para poder usarlas global resultspre; global x; global y; load('c:\matlabr12\work\datapre.mat','resultspre','nompre','metpre','valorpre','stdxpre'); set(handles.dator,'Value',0); %exclusion mutua para los 2 radio buttons x=resultspre; y=rtglobal; % los targets los tiene q cargar el usuario %--------------------------------------------------------------------- function varargout = cargatar_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.cargatar. global rtglobal; [filename,pathname]=uigetfile('*.*','Carregar fitxer targets'); %pillamos el fichero targets nomtar=[pathname,filename]; %se coge la ruta de donde esta el fichero y su nombre resultstar=load(nomtar); %una var. coge los datos de antes rtglobal=resultstar; set(handles.rutar,'String',nomtar); %esto es para mostrar simplemente en la %editbox el archivo de targets seleccionado asi como su path % -------------------------------------------------------------------- function varargout = np_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.np. global np; np=str2num(get(handles.np,'String')); % -------------------------------------------------------------------- function varargout = edit3_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit3. global mg; mg=str2num(get(handles.mg,'String')); % -------------------------------------------------------------------- function varargout = edit4_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit4.

107

global mt; mt=str2num(get(handles.mt,'String')); % -------------------------------------------------------------------- function varargout = edit5_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit5. global wn; wn=str2num(get(handles.wn,'String')); % -------------------------------------------------------------------- function varargout = edit6_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit6. global cn; cn=str2num(get(handles.cn,'String')); % -------------------------------------------------------------------- function varargout = edit7_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit7. global bf; bf=str2num(get(handles.bf,'String')); % -------------------------------------------------------------------- function varargout = edit8_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit8. global cr; cr=str2num(get(handles.cr,'String')); % -------------------------------------------------------------------- function varargout = edit9_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit9. global ml; ml=str2num(get(handles.ml,'String')); % -------------------------------------------------------------------- function varargout = edit10_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit10. global cv; cv=str2num(get(handles.cv,'String')); % -------------------------------------------------------------------- function varargout = edit11_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.edit11. global sp; sp=str2num(get(handles.sp,'String')); % -------------------------------------------------------------------- function varargout = edit12_Callback(h, eventdata, handles, varargin)

108

% Stub for Callback of the uicontrol handles.edit12. global it; it=str2num(get(handles.it,'String')); % -------------------------------------------------------------------- function varargout = ejecuta_Callback(h, eventdata, handles, varargin) % Stub for Callback of the uicontrol handles.ejecuta. global x; global y; global np; global mg; global mt; global wn; global cn; global bf; global cr; global ml; global cv; global sp; global it; [fit,pop] = gaselctr(x,y,np,mg,mt,wn,cn,bf,cr,ml,cv,sp,it); fit pop % -------------------------------------------------------------------- % --------------------------------------------------------------------

109

INGENIERÍA EN AUTOMÁTICA Y ELECTRÓNICA INDUSTRIAL

SISTEMAS DE PERCEPCIÓN

TUTORIAL

110

El presente tutorial describe 3 ejemplos para 3 métodos de reconocimiento de patrones utilizando el software realizado mediante el GUI de Matlab, uno estadístico: Algoritmo Genético y otros dos neuronales: MLP y LVQ. En cualquiera de los casos, con lo primero que nos encontraremos al ejecutar el programa será con el GUI (Graphical User Interface) del menú principal, el cual tiene la siguiente forma:

Lo primero que debemos hacer es cargar el fichero con las medidas pertinentes. Para ello hay que clicar sobre el pulsador “Carregar dades”. Seguidamente se nos abrirá un “browse” y nosotros tendremos que seleccionar el archivo adecuado. A continuación se puede realizar un preprocesamiento de los datos, seleccionando una de entre todas las opciones que nos ofrece la listbox. Una vez hecho esto clicaremos sobre el pulsador “Go”. Como aspecto opcional podemos ver los datos ploteados una vez procesados. Finalmente, como se trata de una ramificación de menús o formularios podremos seleccionar o bien uno de los métodos estadíticos o bien uno de los métodos neuronales de una de las 2 “listbox” presentes.

111

-Algoritmo Genético Mediante el algoritmo genético haremos una selección de variables (determinar un subconjunto de las variables totales) que permita construir un modelo PLS que relacione los datos con los targets. En principio un modelo predictivo será más robusto si utiliza un menor número de variables. De ahí el interés en hacer una selección de las variables a utilizar por el modelo. El formulario principal de este método tiene la siguiente forma:

En este caso en primer lugar debemos cargar el fichero de targets mediante un “browse” que se abrirá una vez cliquemos sobre el pulsador “Fitxer targets”. A continuación deberemos seleccionar si queremos usar los datos preprocesados o bien originales seleccionando uno de los 2 “radiobuttons”.

Finalmente tan sólo hay que rellenar las diferentes “editbox” poniendo los valores comprendidos en el rango que aparece en la etiqueta del parámetro. Y a continuación pulsar en ejecutar.

112

Como ejemplo seleccionaremos las siguientes opciones y fijaremos los valores de los parámetros como se muestra en la figura:

A continuación si clicamos sobre el pulsador “Executa” obtendremos los siguientes resultados:

113

Y en la ventana de comandos se obtienen los valores de los parámentros “fit” y “pop”: The best fitness is 0.0830133 The average fitness is 0.0852838 fit = Columns 1 through 4 0.0830 0.0831 0.0838 0.0844 Column 5 0.0921 pop = Columns 1 through 6

114

0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 1 0 1 0 0 0 1 0 Columns 7 through 10 1 0 0 1 1 0 1 1 1 0 1 1 1 0 0 1 1 0 0 1

El algoritmo ha convergido en la séptima generación: en la generación 7 el 80% de los cromosomas son idénticos).

De los resultados anteriores se deduce que seleccionando las variables 5, 7 y 10 (sólo 3 variables de las 10 disponibles inicialmente) es suficiente para obtener un buen modelo PLS entre los datos y los targets.

-MLP En cuanto al menú MLP, una vez realizado el procedimiento habitual antes descrito en el menú principal, seleccionamos en la “listbox” de métodos neuronales el menú MLP y se nos abre el siguiente formulario:

Como vemos se trata de un menú incompleto debido a que es un menú de tipo progresivo, es decir, los diferentes controles (“listbox”, “editboxes”, etiquetas de texto

115

etc) van surgiendo conforme vamos introduciendo los datos en orden. En este caso se introducirán los siguientes valores y se seleccionarán las opciones que se muestran por etapas en las siguientes figuras:

Como se puede apreciar en la figura superior en primer lugar se han seleccionado los datos preprocesados, a continuación cargamos el fichero de targets y en la parte derecha de la parte superior del formulario decidimos no quitar ninguna fila ni ninguna columna, es decir que tenemos en cuenta todos los sensores y todas las medidas.

Seguidamente, en la parte central del formulario hemos de configurar los parámetros de los que consta nuestra red neural. Para ello primero introducimos el nombre que tendrá la red y después seleccionamos mediante los “radiobuttons” de debajo cuantas capas queremos que tenga la red. Una vez hecho esto en la parte derecha configuramos cada capa fijando el número de neuronas que deseamos que tenga cada capa así como su función de transferencia.

116

Luego hacemos lo propio con la capa nº2. Pero en este caso cambiamos el número de neuronas, el cual será igual necesariamente al número de clases posibles. Si el usuario introdujera cualquier otro valor la variable correspondiente tomaría por defecto un número igual al número de clases existentes. Después volvemos a definir la función de transferencia para esta capa, en este caso “Logsig” y clicamos sobre el pulsador “Ok capa”. Finalmente, seleccionamos el modo de entrenamiento que deseamos de una “listbox”.

117

Finalmente rellenamos la última parte del formulario introduciendo el número de “epochs”, “goals” y a continuación seleccionamos el método de validación “Per Parts”. Para emplear dicho método debemos indicar el porcentaje de vectores de testeo en la “editbox” habilitada para este fin.

Tras simular con esta serie de parámetros fijados obtenemos los siguientes resultados:

118

En la figura de arriba se puede apreciar el error existente en la última de las iteraciones. En la ventana de comandos en cambio, se nos muestra la media de aciertos de todas las iteraciones realizadas:

mediaciertos =

75.1020

119

-LVQ Una vez introducidos los datos necesarios en el formulario principal abrimos el formulario o menú correspondiente al método LVQ:

Al igual que en el método MLP rellenaremos todos las “editbox” y seleccionaremos los “radiobuttons” que se muestran en la parte superior. Como número de conjuntos “bootstrap” pondremos 3 y el porcentaje de vectores de entrenamiento introducido será del 80%. Para estos valores los resultados obtenidos son los siguientes:

120

Y en la pantalla de comandos obtenemos que la media de aciertos para estos valores de los parámetros es:

mediaciertos =

38.1164

121

INGENIERÍA EN AUTOMÁTICA Y ELECTRÓNICA INDUSTRIAL

SISTEMAS DE PERCEPCIÓN

PRÁCTICA 1

INTRODUCCIÓN A LOS MÉTODOS DE RECONOCIMIENTO DE PATRONES I

122

OBJETIVO La presente práctica pretende familiarizar al alumno con los métodos de reconocimiento de patrones. En concreto nos centraremos en el método estadístico PCA.

INTRODUCCIÓN

-Métodos de reconocimiento de patrones El campo de los métodos de reconocimiento de patrones es muy actual. Básicamente se trata de clasificar una serie de medidas a partir de la información captada por múltiples sensores para su posterior análisis. Dicha clasificación se realiza a partir de una serie de técnicas matemáticas y estadísticas. Evidentemente el uso de estas técnicas resulta más necesario e indicado cuantos más sensores tengamos. Generalmente se trata de matrices o agrupaciones de sensores. Las areas en las que se hace uso de dichas técnicas son muy numerosas, desde la inteligencia artificial donde por ejemplo los robots necesitan tomar decisiones en base a multitud de información obtenida por sus sensores, pasando por la agricultura (maduración de la fruta), en la industria química para analizar la composición de los gases, etc. Estos métodos se recurren a una serie de bases de datos para finalmente clasificar las medidas en uno u otro grupo. Dicha información facilitará en gran medida las decisiones a tomar por el sistema encargado de procesar la información.

Figura 1: Etapas en el proceso de identificación de patrones Como se puede apreciar en la figura partimos de una agrupación de sensores a partir de los cuales captamos unas señales o medidas. De dichas señales realizamos una extracción de características con la finalidad de obtener información relevante para la identificación, eliminar a su vez los efectos cuantitativos respecto a los efectos cualitativos y finalmente reducir la dimensionalidad del problema. Generalmente antes de someter a los datos o medidas a un método de reconocimiento de patrones, se realiza un preprocesamiento de los datos. Mediante este preprocesamiento se realiza una selección tanto de los sensores que vamos a tener en cuenta como de las variables.

MATRIZ DE SENSORES

EXTRACC. DE CARACT.

CLASIFICCIDENTIFIC. PATRON

123

-Pca Análisis de Componentes Principales es método de reconocimiento de patrones estadístico ya que no se basa en redes neuronales y además no supervisado puesto que no se contrastan los resultados obtenidos con las clases o targets reales a las que pertenece cada medida. La finalidad de este método es representar eficientemente los datos y reducir la dimensionalidad. Se parte de un espacio multidimensional para representar toda una serie de medidas, y el objetivo es establecer un nuevo sistema de coordenadas con menos dimensiones que el real u original, pero que aporte una información similar. Los nuevos ejes de referencia son las componentes principales, y la dirección y sentido que tendrán será hacia donde esté la máxima varianza residual. En cuanto a la disposición relativa entre ellas, serán ortogonales entre sí:

Como se puede apreciar en la fórmula superior las componentes principales es igual a los diferentes sensores multiplicados por los loadings o pesos que tienen cada uno en los nuevos ejes de referencia. Si tenemos en cuenta muchas componentes principales entonces estamos considerando zonas de cada vez menos variabilidad, con lo cual podemos estar midiendo ruido. Por otro lado si los loadings de dos sensores son muy parecidos entonces es que ambos nos están dando información redundante con lo cual podemos prescindir de uno de ellos y entonces conservamos datos similares. Finalmente en el caso en el que haya medidas que se encuentren fuera de los planos considerados, entonces es que se trata de residuos que no aportan información relevante al sistema.

pp ssPC 1111 ... αα ++=

124

REALIZACIÓN PRÁCTICA 1).El menú principal del GUI para el reconocimiento de patrones es el siguiente:

En primer lugar carga el fichero de datos en el menú principal y haz un centrado de los datos. Plotea los datos preprocesados. ¿Por qué es conveniente realizar un preprocesado de los datos antes de aplicar un método de reconocimiento de patrones?.

2).El menú principal del método PCA tiene el siguiente diseño:

125

Selecciona el método PCA de la “listbox” correspondiente a los métodos estadísticos. Observa que en el menú salen 10 dimensiones y el objetivo del PCA es reducir mediante el uso de componentes principales dicho valor para representar la misma información con un menor nº de coordenadas. Fija el nº de componentes principales a 2 y clica sobre el pulsador “Go”. A continuación introduce en las “editbox” de los ejes: Eje X:1, Eje Y:2 y por último Eje Z:2. Finalmente plotea los “loadings” y los “scores”. ¿Qué sensores descartarías?¿Por qué razón?¿Podremos representar la misma información que antes con los sensores que hemos conservado? Define los conceptos de “loading” y “score” y justifica matemáticamente tu explicación.

126

INGENIERÍA EN AUTOMÁTICA Y ELECTRÓNICA INDUSTRIAL

SISTEMAS DE PERCEPCIÓN

PRÁCTICA 2

INTRODUCCIÓN A LOS MÉTODOS DE RECONOCIMIENTO DE PATRONES II

127

OBJETIVO

La presente práctica pretende seguir la misma línea que la anterior. En este caso se trata de introducir al alumno en los métodos de reconocimiento de patrones neuronales, en concreto el MLP.

INTRODUCCIÓN

Se trata de un método basado en redes neuronales, el cual es supervisado, no lineal y no paramétrico. Su función es realizar clasificaciones en cuanto a cuantificaciones. Se trata de una red unidireccional y su arquitectura típica es la siguiente:

Figura 2: Arquitectura de red MLP

Las neuronas de la capa oculta usan como regla de propagación la suma ponderada de las entradas con los pesos sinápticos wij y sobre esa suma ponderada se aplica una función de transferencia de tipo sigmoide, que es acotada en respuesta. La forma funcional de una sigmoide es del tipo:

Figura 3: Señal Sigmoide

El aprendizaje que se suele usar en este tipo de redes recibe el nombre de retropropagacion del error (backpropagation). Como función de coste global, se usa el error cuadratico medio.

128

REALIZACIÓN PRÁCTICA 1):Al igual que en la práctica del PCA introduce los datos en el formulario principal y haz un preprocesado de centrado. Después selecciona el método MLP. El menú tiene la siguiente forma:

En primer lugar selecciona los datos preprocesados y después carga el fichero de targets. A continuación no elimines ninguna fila ni ninguna columna ni de sensores ni de medidas. Seguidamente crea la red, e introduce los siguientes datos: Nombre de la red, nº de capas=2, nºneuronas de la capa 1=8 y nº de neuronas de la capa 2=5. ¿Por qué el nº de neuronas de la capa de salida es 5?¿Podría ser cualquier otro valor?¿Por qué?

2).Selecciona las funciones de transferencia de cada capa, la primera “Tansig” y la segunda “Logsig”. A continuación selecciona como modo de entrenamiento Traingdx. Por último sólo nos queda seleccionar el método de validación, para ello primero fijaremos el nº de “epochs” a 300 y el de “goals” a 0. Finalmente elije el método de validación “Per Parts” e introduce un porcentaje de vectores de testeo del 20%. Entrena y simula la red. Apunta los resultados obtenidos. Ahora haz exactamente lo mismo pero introduce un 80% de vectores de testeo. Realiza una comparativa con los resultados obtenidos antes y con los resultados obtenidos ahora?¿Por qué se da esa diferencia en la media de aciertos?¿Tiene alguna relación lineal o de proporcionalidad el porcentaje de vectores de testeo con la media de aciertos?Explica con detalle el proceso de validación

129

“Por partes”. ¿Sería posible aplicar este método a métodos no supervisados?¿Por qué?¿Qué ventaja tienen los métodos supervisados sobre los que no lo son?