cenidet · las manzanas en donde las reglas descriptivas y los ejemplos numéricos son conocidos,...

T E S I S PARA OBTENER EL GRADO DE MAESTRO EN CIENCIAS EN CIENCIAS COMPUTACIONALES P R E S E N T A : VIANEY GUADALUPE CRUZ SÁNCHEZ

SEP SEIT DGIT

CENTRO NACIONAL DE INVESTIGACIÓN Y DESARROLLO TECNOLÓGICO

cenidet

SISTEMA HÍBRIDO NEURO-SIMBÓLICO PARA REFINAR EL CONOCIMIENTO EN UN SISTEMA DE VISIÓN ARTIFICIAL

Directores de tesis: DR. GERARDO REYES SALGADO DR. RAÚL PINTO ELÍAS

CUERNAVACA, MORELOS AGOSTO DEL 2004

DEDICATORIAS

A dios por enseñarme que a pesar de las adversidades se logra lo que se desea con todo el corazón. A mi padre que aunque ya no se encuentra físicamente en la tierra, sé que cuento con su apoyo desde donde quiera que él esté. A mi madre que siempre está conmigo apoyándome en todo momento y que me ha enseñado que uno es el arquitecto de su vida. A mi hermana que más que eso se ha convertido en una gran amiga con el paso de los años. A mi hermano, por ser la figura paterna que representa en mi familia, al cual admiro y respeto. A mis sobrinos por ser los que me dan alegría y ganas de seguir adelante con tan solo un abrazo de ellos. A Yary, Cris y Abril. A mi novio Osslan por ser la persona a la que amo, admiro y que me enseña a que las cosas se pueden lograr con un poco más de esfuerzo. A mis amigas Nubia, Leonor, Selene, Andrea, por estar conmigo en los momentos difíciles y compartir un poco de su vida y experiencias conmigo. A mis amigos César, Emilio, May, Jorge, Isidro, Iván, Rodrigo, Armando, José, Alonso, etc., por compartir sus alegrías y contar con sus consejos.

AGRADECIMIENTOS

A mi asesor el Dr. Gerardo Reyes Salgado por todos los consejos y conocimientos compartidos conmigo y sobre todo por su amistad. A mis revisores M. en C. Andrea Macadán Salazar, M. en C. Manuel Mejía Lavalle, M. en C. Matilde Velazco Sony, por todos los comentarios y su colaboración para el desarrollo de este trabajo de investigación. Al centro nacional de investigación y desarrollo tecnológico (cenidet), por darme la oportunidad de perteneceer a esta gran institución. Al Consejo del Sistema Nacional de Educación Tecnológica (cosnet) por el apoyo económico. A todos los que de alguna forma colaboraron con este trabajo de investigación.

RESUMEN El desarrollo de la investigación en la Inteligencia Artificial (IA) se ha conducido en

diferentes direcciones, ya sea en el uso de métodos de IA simbólicos o en el uso de métodos

conexionistas (redes neuronales artificiales). Estos dos enfoques han sido aplicados

separadamente en la solución de problemas que requieren tareas de adquisición de

conocimiento y de aprendizaje, aunque muchas veces ni uno ni otro enfoque por sí solos

permiten cubrir el dominio de conocimiento que representan en su totalidad.

En este trabajo de tesis se presentan los resultados de la implementación de un sistema

híbrido neuro-simbólico que permite unificar estos dos tipos de representación del

conocimiento. Para lograr lo anterior, se desarrolló un compilador o traductor de reglas

simbólicas el cual toma como entrada un conjunto de reglas del tipo SI…ENTONCES

convirtiéndolas en una representación conexionista.

Una vez obtenida la red neuronal artificial compilada ésta es utilizada como una red

neuronal inicial en el proceso de aprendizaje que permite el refinamiento del conocimiento.

Para verificar el poder del refinamiento del enfoque híbrido, se realizó un conjunto de

pruebas que demuestran que en ocasiones es posible mejorar el porcentaje de casos

correctamente clasificados. Las reglas utilizadas para las pruebas, provienen de los casos de

estudio utilizados en esta tesis, uno de ellos es la clasificación visual de objetos tales como

las manzanas en donde las reglas descriptivas y los ejemplos numéricos son conocidos, el

otro se trata del problema méramente académico Monk’s. En ambas pruebas se comprobó

que en algunos casos un sistema híbrido neuro-simbólico obtiene un mejor resultado, que el

que se obtiene utilizando un enfoque por separado.

ABSTRACT The development of Artificial Intelligence (AI) research has followed mainly in two

different directions: the use of symbolic AI methods and the use of connectionist methods

(artificial neural networks). These two approaches have been applied separatly in the

resolution of problems that requires tasks of knowledge adquisition and learning, although

many of the times neither approach by itself allows to cover the domain of knowledge that

they seek to represent totally.

In this thesis we present the results of implementing a neuro-symbolic hybrid system that

allows unifying these two types of knowledge representation. For this, we have developed a

compiler or translator of symbolic rules which takes as an input a group of rules of the type

IF…THEN…, converting them into a connectionist representation.

Once obtained the compiled artificial neural network it is used as an initial neural network

in a learning process that will allow the refinement of the knowledge. In order to verify the

power of refinement of the hybrid approach, we carried out a group of test that show that it

is possible to improve the percentage of cases correctly classified. The rules used for the

tests, come from the used cases of study in this thesis, one of them is the visual

classification of objects such apples in where the descriptive rules and the numerical

examples are known, the other is the academic problem named Monk's. In both tests it was

verified that in some cases a neuro-symbolic hybrid system obtains a better result, than the

one that is obtained separately using an knowledge approach.

i

Contenido Págs.

Tabla de contenido………………………..…..………………………………………..…..i Listado de figuras………………………..…………………………………………….….iv Listado de tablas………………………..………………………………………………....vi

CAPÍTULO 1 INTRODUCCIÓN ....................................................................................... 1

1.1Antecedentes……………………………………………………...…………………...1

1.2 Planteamiento del problema ......................................................................................... 2 1.3 Objetivo ........................................................................................................................ 3 1.3 Método de solución....................................................................................................... 3 1.4 Beneficios ..................................................................................................................... 5 1.5 Alcances........................................................................................................................ 5 1.6 Limitaciones ................................................................................................................. 5 1.7 Organización del documento ........................................................................................ 6

CAPÍTULO 2 ESTADO DEL ARTE ................................................................................. 7

2.1 Integración de aprendizaje simbólico y neuronal ......................................................... 7 2.2 Interpretación de redes neuronales artificiales: mapeando redes neuronales artificiales en reglas .............................................................................................................................. 7 2.3 Máquina de aprendizaje constructiva: un nuevo enfoque neuro- simbólico .............. 10 2.4 Sistema de visión artificial para el control de calidad del melón............................... 11

2.5 Otras referencias……………………………………………………………………..13 2.6 Conclusiones y discusión……………………………………………………………15

CAPÍTULO 3 MARCO TEÓRICO.................................................................................. 16

3.1 Conocimiento.............................................................................................................. 16

3.1.1 Conocimiento Simbólico ..................................................................................... 17 3.1.2 Conocimiento Numérico...................................................................................... 18

3.2 Sistema de visión artificial.......................................................................................... 19 3.2.1 Etapas de un sistema de visión artificial.............................................................. 19

3.3 Ingeniería del conocimiento ....................................................................................... 20 3.3.1 Qué es la ingeniería del conocimiento ................................................................. 20 3.3.2 Adquisición del conocimiento ............................................................................. 21 3.3.3 Adquisición del conocimiento de una fuente estática.......................................... 21 3.3.4 Adquisición del conocimiento de una fuente dinámica ....................................... 21 3.3.5 Representación del conocimiento ........................................................................ 22 3.3.6 Validación del conocimiento ............................................................................... 22

3.4 Redes neuronales artificiales ...................................................................................... 22 3.4.1 La red neuronal artificial vista como un modelo biológico ................................. 23

ii

3.4.2 Elementos de una red neuronal artificial ............................................................. 23 3.4.3 Estructura de la red neuronal artificial................................................................. 24 3.4.4 Características de las redes neuronales artificiales .............................................. 24 3.4.5 Ventajas de las redes neuronales artificiales ....................................................... 25

3.5 Sistemas híbridos neuro-simbólicos ........................................................................... 26 3.5.1 Modelos independientes ...................................................................................... 27 3.5.2 Modelos transformacionales ................................................................................ 27 3.5.3 Modelos ligeramente acoplados .......................................................................... 28 3.5.4 Modelos fuertemente acoplados .......................................................................... 29 3.5.5 Modelos totalmente integrados ............................................................................ 29

3.6 Discusión………………………………………………………………………….30 CAPÍTULO 4 MODELO CONCEPTUAL DEL COMPILADOR SIMBÓLICO....... 31

4.1. Principios en los que se basó CompSimb .................................................................. 31 4.2. Arquitectura de la herramienta .................................................................................. 34

4.2.1 Mapeo de las reglas a la RNA………………………………………………..34 4.2.1.1 Representación simbólica: atributos y reglas……….………………34

4.2.1.2 Tipos de atributos…………………………………………………..34 4.2.1.3 Tipos de reglas……………………………………………………...37

4.2.1.4 Algoritmo de traducción de las reglas a la red neuronal artificial….43 4.2.2 Pseudo código de traducción de reglas a red neuronal........................................ 48 4.2.3 Diseño y compilación del archivo simbólico en el sistema ................................. 49

4.3. Interfaz del usuario .................................................................................................... 51 4.3.1 Descripción del archivo de topología .................................................................. 58 4.3.2 Descripción del archivo de pesos ........................................................................ 60

CAPÍTULO 5 CASO DE ESTUDIO................................................................................. 61

5.1 Calidad en los alimentos: el caso de las frutas ........................................................... 61

5.1.1 Atributos externos................................................................................................ 63 5.1.2 Atributos internos ................................................................................................ 64 5.1.3 Atributos ocultos.................................................................................................. 65

5.2 Normas de calidad para manzanas.............................................................................. 66 5.2.1 Características ...................................................................................................... 66 5.2.2 Clasificación ........................................................................................................ 66

5.3 Especies de manzanas ................................................................................................. 67 5.3.1 Manzana "Golden Delicious" .............................................................................. 67 5.3.2 Manzana "Red Delicious".................................................................................... 68 5.3.3 Manzana "Gala" .................................................................................................. 69 5.3.4 Manzana " Fuji"................................................................................................... 69 5.3.5 Manzana "Granny smith"..................................................................................... 70 5.4 Discusión………………………………………………………………………….71

iii

CAPÍTULO 6 PRUEBAS Y RESULTADOS................................................................... 73

6.1 Caso de estudio “monks problem”.............................................................................. 73

6.1.1 Atributos .............................................................................................................. 73 6.1.2 Regla de producción del caso de estudio “monks” .............................................. 74 6.1.3 Implementación del caso de estudio “monks problem” en el sistema CompSimb...................................................................................................................................... 74 6.1.4 Resultados obtenidos ........................................................................................... 77 6.1.5 Análisis de resultados .......................................................................................... 81

6.2 Caso de estudio “calidad en las manzanas”................................................................ 82 6.2.1 Atributos .............................................................................................................. 82 6.2.2 Reglas de producción del caso de estudio “calidad en las manzanas” ................ 82 6.2.3 Implementación del caso de estudio calidad en las manzanas en el sistema CompSimb .................................................................................................................... 83 6.2.4 Resultados obtenidos ........................................................................................... 85 6.2.5 Análisis de resultados .......................................................................................... 95

6.2.6 Análisis interno de la red neuronal artificial antes y después del "refinamiento"96 CAPÍTULO 7 CONCLUSIONES ..................................................................................... 97

7.1 Conclusiones generales............................................................................................... 97 7.2 Lecciones aprendidas………………………………………………………………..97 7.3 Aportaciones ............................................................................................................... 98 7.4 Trabajos futuros .......................................................................................................... 99

ANEXO A Bibliografía general....................................................................................... 100 ANEXO B Glosario de términos ..................................................................................... 104 ANEXO C Detalle del código…………………………………………………………...108 ANEXO D Detalle de experimentos…………………………………………………….134

iv

LISTADO DE FIGURAS

Descripción Pág. Figura 1.1: Funcionamiento del Sistema Híbrido Neuro – Simbólico INSS…………. Figura 2.1: Marco de trabajo para la combinación de aprendizaje simbólico y neuronal…………………………………………………………………... Figura 2.2: Refinamiento de las reglas utilizando las redes neuronales artificiales...... Figura 3.1: Manzana Golden…………………… …………………………………… Figura 3.2: Pera……………………………………………………………………….. Figura 3.3: Módulos que constituyen un sistema de visión artificial………………… Figura 3.4: Niveles o capas en una RNA…………………………………………....... Figura 3.5: Modelos de hibridación en los sistemas…………….………………......... Figura 4.1: Integración del conocimiento externo en un SVA……………………….. Figura 4.2: Dos tipos de representación unidos en un SHNS………………………… Figura 4.3: Etapas de un sistema híbrido neuro-simbólico completo……………....... Figura 4.4: Esquema general del sistema de traducción de reglas simbólicas a una RNA (CompSimb)……………………..……………………………. Figura 4.5: Traducción de atributos de tipo binario y de tipo rango en la RNA……… Figura 4.6: Traducción de atributos de tipo nominal/continuas en la RNA…………... Figura 4.7: Rescribiendo las reglas con un mismo consecuente……………………... Figura 4.8: Correspondencia entre nuestro conocimiento base y la red neuronal……. Figura 4.9: Mapeo de reglas a una red neuronal y las fórmulas aplicadas en la misma……………………………………………………………..... Figura 4.10: Nivel determinado mediante la mínima distancia de una unidad de entrada……………………………………………………………………. Figura 4.11: Nivel determinado mediante la máxima distancia de una unidad de entrada……………………………………………………………………. Figura 4.12: Ejemplo de la traducción de reglas a una red neuronal………………….. Figura 4.13: Simbología empleada en el archivo de entrada…………………………... Figura 4.14: Palabras reservadas empleadas en el archivo de entrada………………… Figura 4.15: Pantalla principal del sistema CompSimb……………………………….. Figura 4.16: Carga del archivo simbólico en el sistema……………………………….. Figura 4.17: Archivo correctamente compilado por el sistema ANTLR……………… Figura 4.18: En la parte derecha, dentro de la pestaña Atributos se visualizan los atributos de nuestro archivo simbólico………………………………... Figura 4.19: En la parte derecha, dentro de la pestaña Reglas se visualizan las reglas de nuestro archivo simbólico……………………………………… Figura 4.20: Pantalla de opciones de compilación…………………………………….. Figura 4.21: Fin de la compilación de las reglas a la red neuronal….…………………. Figura 4.22: Archivos *.top a la derecha y *.wts a la izquierda de la pantalla……….

4 7 9 17 17 19 24 27 31 32 33 33 36 36 43 44 45 46 46 47 49 49 52 52 53 54 54 56 56 57

v

Figura 4.23: Interfaz creada para llevar a cabo la integración desde modo MS-DOS……. Figura 5.1: Manzana Golden Delicious…………………………………………………… Figura 5.2: Manzana Red Delicious…………………………………………… …………. Figura 5.3: Manzana Gala……………………………………………………………….... Figura 5.4: Manzana Fuji………………………………………………………..………… Figura 5.5: Manzana Granny Smith……………………………………………...……….. Figura 6.1: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio Monk's problem………………………………………………………. Figura 6.2: Porcentaje de generalización entre el enfoque conexionista con 100 ejemplos y el enfoque híbrido de Monk's problem……………………………. Figura 6.3: Porcentaje de generalización entre el enfoque conexionista con 75 ejemplos y el enfoque híbrido de Monk's problem………………………......... Figura 6.4: Porcentaje de generalización entre el enfoque conexionista con 50 ejemplos y el enfoque híbrido de Monk's problem……………………………. Figura 6.5: Porcentaje de generalización entre el enfoque conexionista con 25 ejemplos y el enfoque híbrido de Monk's problem……………………. Figura 6.6: Porcentaje de generalización entre el enfoque simbólico con el total de reglas y el enfoque híbrido de Monk's problem……………………………………… Figura 6.7: Porcentaje de generalización entre el enfoque simbólico con la regla R1 y el enfoque híbrido de Monk's problem. Figura 6.8: Porcentaje de generalización entre el enfoque simbólico con la regla R2 y el enfoque híbrido de Monk's problem………………………………………….. Figura 6.9: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio "calidad en las manzanas" categoría Extra……………………………. Figura 6.10: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio "calidad en las manzanas" categoría I………………………………… Figura 6.11: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio "calidad en las manzanas" categoría II………………………………... Figura 6.12: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio "calidad en las manzanas" categoría III……………………………….. Figura 6.13: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio "calidad en las manzanas" Todas las categorías………………………. Figura 6.14: Porcentaje de generalización entre el enfoque conexionista con 100 ejemplos y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III". Figura 6.15: Porcentaje de generalización entre el enfoque conexionista con 75 ejemplos y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III". Figura 6.16: Porcentaje de generalización entre el enfoque conexionista con 50 ejemplos y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III". Figura 6.17: Porcentaje de generalización entre el enfoque conexionista con 25 ejemplos y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III". Figura 6.18: Porcentaje de generalización entre el enfoque simbólico con R7 y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III"…………… Figura 6.19: Porcentaje de generalización entre el enfoque simbólico con R5 y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III"………….... Figura 6.20: Porcentaje de generalización entre el enfoque simbólico con R4 y el enfoque híbrido de la calidad en las manzanas "categoría Extra, I, II y III"…………….

57 57 68 68 69 70

77

78

78

79

79

80

80

81

86

87

88

90

91

92

92

93

93

94

94

95

vi

LISTADO DE TABLAS Descripción Págs. Tabla 4.1: Correspondencia entre el conocimiento base y la RNA…………………... Tabla 5.1: Atributos utilizados en este trabajo………………………..……………… Tabla 5.2: Rango de valores para el RGB de cada manzana según su categoría…….. Tabla 6.1: Discretización de los atributos para el caso Monk's problem ……………. Tabla 6.2: Resultados obtenidos en el caso de estudio Monk's problem……………... Tabla 6.3: Valores de RGB para el caso de la manzana Golden……………………... Tabla 6.4: Discretización de los atributos para el caso de calidad en las manzanas…. Tabla 6.5: Resultados obtenidos en el caso de control de calidad categoría_extra…... Tabla 6.6: Resultados obtenidos en el caso de control de calidad categoría_I……….. Tabla 6.7: Resultados obtenidos en el caso de control de calidad categoría_II……… Tabla 6.8: Resultados obtenidos en el caso de control de calidad categoría_III……... Tabla 6.9: Resultados obtenidos en el caso de control de calidad de las 4 categorías..

34 71 71 74 77 83 83 86 87 88 89 91

1

CAPÍTULO 1 INTRODUCCIÓN

En este capítulo, se presenta la información para saber en qué consiste este trabajo de investigación. Para ello, se exponen temas tales como, los antecedentes del trabajo, el planteamiento del problema, que lo ubica en el contexto en el cual se encuentra inmerso, los objetivos que se pretenden alcanzar, la metodología utilizada para dar solución, los logros, las limitaciones de este trabajo y finalmente la organización del documento. 1.1 Antecedentes Este proyecto se llevó a cabo en el grupo de visión artificial de Cenidet el cual desde el año de 1996 inició el desarrollo de diversos sistemas dirigidos al procesamiento digital de imágenes, al reconocimiento de patrones, la visión artificial y la robótica. El área de la visión artificial se encarga de resolver entre otros, problemas relacionados con el reconocimiento de objetos, siendo ésta una herramienta útil en problemas donde el ser humano necesita captar con precisión los detalles más pequeños dentro de una imagen, como por ejemplo en el análisis de imágenes médicas. Uno de los campos de aplicación de las técnicas de reconocimiento de imágenes es la determinación de la calidad de los objetos. En industrias tales como la textil [Vergara-2003] y la agroindustria [Fuentes -2003], el reconocimiento de la calidad de sus productos como telas y/o manzanas es realizado directamente por el experto humano. Una razón por la cual un sistema automático de reconocimiento de imágenes es aplicable a este tipo de industrias es el cansancio visual que conlleva el realizar esta tarea al experto humano y que un sistema de este tipo puede reducir. Entre las dificultades del reconocimiento visual de la calidad se encuentran: la gran cantidad de información proveniente de las señales tanto del objeto a evaluar como del entorno (representado como conocimiento numérico) así como la definición de los criterios de calidad con que el experto califica al objeto, comúnmente representado con conocimiento cualitativo. Este último, puede formalizarse por medio de alguna estructura simbólica tales como reglas, casos, árboles, etc., (conocimiento simbólico) [Henao-1998]. Una alternativa para mejorar este proceso de reconocimiento visual es la integración del conocimiento numérico y el conocimiento simbólico en una sola herramienta informática, pues su tratamiento de manera separada genera un problema de incompletitud. Esta incompletitud puede ser debida a que el conocimiento numérico puede contener de manera

Capítulo 1 Introducción

2

implícita conocimiento simbólico en forma no explícita por el experto humano y viceversa [Towell-1991]. Es decir, el conocimiento numérico contenido en la base de conocimiento de un sistema de visión artificial además de que no es fácil de ser traducido por un usuario común, puede haber conocimiento implícito del experto humano que aún no es interpretado como tal. Por otro lado, el conocimiento simbólico puede carecer del conocimiento proveniente del sistema de visión artificial y que puede ayudar a complementar las reglas que ayuden al reconocimiento visual de un objeto, por mencionar un ejemplo. En lo que respecta al Sistema de Visión Artificial (SVA), en el corazón del mismo se encuentra una base de conocimientos, la cual interactúa con todas las demás etapas (ver capítulo 3, sección 3.2.1) [González-1996]. En este proyecto de tesis se estudió los mecanismos para integrar en un sistema híbrido neuro-simbólico, los conocimientos numéricos junto con los conocimientos simbólicos. La integración de estos dos tipos de conocimientos permitió crear un Módulo de Conocimiento Inteligente (MCI) basado en los principios de los Sistemas Híbridos Neuro - Simbólicos (SHNS). El crear un SHNS, permite que se puedan aprovechar las fortalezas de dos subsistemas: un sistema simbólico (reglas) y un sistema conexionista (Red Neuronal Artificial (RNA)), y obtener como resultado un conocimiento refinado (mejorado) el cual complementa ambos tipos de conocimientos. La hipótesis de esta tesis en el sentido de que un SHNS puede obtener un conocimiento mejorado es demostrada experimentalmente. 1.2 Planteamiento del problema En la actualidad, para determinar la calidad de frutas (tales como las manzanas) la agroindustria utiliza el conocimiento empírico de sus expertos humanos (conocimiento simbólico), por lo que el proceso que se lleva a cabo puede ser muy cansado para los mismos o incluso puede consumir tiempo para la capacitación de los nuevos inspectores de calidad. Debido a esto, surge la necesidad de contar con sistemas automáticos capaces de evaluar la calidad visual de estas frutas (conocimiento numérico). El integrar el conocimiento simbólico con el conocimiento numérico aumenta la eficiencia de los sistemas, ya que permite tener un conjunto de conocimientos más completo sobre el dominio de un problema [Fernández-2000]. Los conocimientos simbólicos fueron obtenidos a partir de los conocimientos de expertos humanos mediante un conjunto de reglas que determinan la calidad visual de manzanas, mientras que los conocimientos numéricos, provienen de datos extraídos por un sistema de inspección a partir de imágenes digitalizadas de manzanas; para esta tesis se trabajó con la inspección visual de las manzanas.


3

1.3 Objetivo El objetivo que se propuso fue : investigar, analizar, diseñar, implementar y probar un SHNS capaz de integrar tanto conocimiento simbólico como numérico, obtenido de un experto humano y de una base de datos (una de imágenes y otra de datos) respectivamente. Este sistema será capaz de traducir y aprender ambos conocimientos para el reconocimiento de la calidad de los objetos utilizados, por ejemplo, en un sistema de visión artificial. Para ello, se tiene como caso de estudio el problema de la calidad visual en las manzanas. 1.4 Método de solución Durante los últimos años se ha desarrollado una importante serie de trabajos que buscan disminuir la distancia entre los paradigmas simbólico y conexionista: los sistemas híbridos neuro – simbólicos. [Wertmer-2000] propone una definición que esta relacionada a esta investigación: “los sistemas híbridos neuro – simbólicos son sistemas basados principalmente en RNA’s, que permiten una interpretación simbólica o una interacción con componentes simbólicos”. Diversos autores han propuesto sistemas del tipo descrito por Wertmer tales como [Fletcher-1994] y [Sun-1995]. Algunos de estos sistemas son KBANN [Towell-1991], SYNHESYS [Giacometi-1992] e INSS [Osorio-1998]. Estos tres trabajos utilizan redes neuronales artificiales tipo perceptrón para el tratamiento de reglas simbólicas clásicas del tipo: “Si…Entonces…”. Estos sistemas hacen la transferencia de los conocimientos representados por un conjunto de reglas simbólicas hacia un módulo conexionista. La red neuronal obtenida de esta manera, permite un aprendizaje supervisado a partir de un conjunto de ejemplos. En una etapa posterior se aplica a esta red un algoritmo de explicitación (extracción) de reglas. Las reglas obtenidas son entonces comparadas a las reglas iniciales. De esta manera, se tiene un sistema de “adquisición constructiva de conocimientos”. La figura 1.1 muestra el esquema de un SHNS que sigue estas etapas.


4

(1) Reglas Simbólicas

(1) Módulo Simbólico

(2) Módulo Conexionista

(2) Base de ejemplos

(1) Convertidor Reglas " RNA

(1) RNA Inicial

(2) RNA refinada

(3) Reglas Refinadas

(3) Convertidor RNA " Reglas

(4) M Ó D U L O D E V A L I D A C I Ó N

Figura 1.1: Funcionamiento del Sistema Hibrido Neuro - Símbolico INSS [Osorio- 1998].

Las etapas que involucra un SHNS son las siguientes:

1) Compilación de reglas en una RNA inicial. En esta etapa, las reglas simbólicas proporcionadas por un experto humano son representadas simbólicamente (Módulo simbólico) y convertidas en una red neuronal artificial la cual es llamada RNA “inicial”.

2) Aprendizaje conexionista. Para esta etapa, se implementa un módulo conexionista el

cual recibe la RNA inicial. Esta red es sometida a un proceso de aprendizaje a partir de la base de ejemplos. Al final de esta etapa, se obtiene una red neuronal artificial la cual es llamada RNA “refinada”.

3) Explicitación de reglas de una RNA. En esta etapa, se realiza la extracción de reglas

simbólicas a partir de la red neuronal artificial refinada. A estas reglas se les llama reglas “refinadas”.

4) Validación de reglas. En esta etapa, se somete al conjunto de reglas generadas a una

doble validación: a) con las reglas que son obtenidas inicialmente por el experto humano y b) las nuevas reglas generadas por el sistema que no han sido consideradas, son validadas directamente por el experto.

En el presente trabajo de investigación, se llevaron a cabo las dos primeras etapas. Actualmente se está estudiando el problema de la explicitacion [González-2004].


5

1.4 Beneficios Los beneficios que se esperan obtener con este trabajo de investigación fueron los siguientes:

1. Obtener una metodología para la integración de conocimiento numérico y simbólico en un SHNS que pueda ser utilizado posteriormente en los SVA. Actualmente no existen metodologías que de manera automática integren estos dos tipos de conocimiento en un SVA.

2. Proporcionar un prototipo de herramienta que pueda ayudar posteriormente en la

etapa de reconocimiento en un SVA. Con especial énfasis en el problema de la determinación de la calidad.

3. Aumento de la eficiencia y flexibilidad de los sistemas híbridos neuro-simbólicos.

1.5 Logros Los principales logros que se pretenden obtener durante el desarrollo de la tesis fueron:

1. Implementación de un módulo de conversión de las reglas simbólicas del experto

humano a una RNA (Módulo de compilación de reglas-RNA). 2. Implementación de un módulo de integración del conocimiento simbólico y del

conocimiento numérico en un sistema de reconocimiento de calidad (Módulo de integración numérico-simbólico).

1.6 Alcances y limitaciones El sistema que se desarrollará tiene las siguientes características:

1. Manejo de únicamente reglas simbólicas del tipo Si…Entonces como método de

representación de conocimiento, en vez de árboles u otros tipos de representación. 2. Utilización de la red neuronal artificial backpropagation como herramienta para la

integración de nuevos conocimientos.

3. El sistema fue desarrollado en una plataforma Windows XP, pentium 4, a 1.5 GHz con 256 MB.

4. No se implementó un sistema que obtuviera automáticamente los atributos visuales

de los objetos. Éste es un problema que se está actualmente trabajando dentro del grupo de visión artificial de CENIDET.


6

1.7 Organización del documento Este trabajo de investigación se estructura de la siguiente forma: El capítulo 2, estado del arte, presenta los estudios relacionados al tema central de la tesis: la compilación de reglas simbólicas y su integración con el conocimiento numérico en los sistemas híbrido neuro-simbólicos. El capítulo 3, marco teórico, presenta las bases sobre las cuales se sustenta el conocimiento para el desarrollado de este trabajo que incluye temas como: el conocimiento, los sistemas de visión artificial, la ingeniería del conocimiento, las redes neuronales artificiales y los sistemas híbridos neuro-simbólicos. El capítulo 4, modelo conceptual del sistema, presenta la estructura general del sistema, el funcionamiento del mismo y la interfaz que es presentada al experto o usuario del sistema. El capítulo 5, caso de estudio, presenta la información que se consideró como la aplicación del sistema de traducción de las reglas simbólicas a una red neuronal artificial. El capítulo 6, pruebas experimentales, presenta los casos de prueba que se utilizaron así como las bases de ejemplos empleadas para la realización de las mismas, la evaluación de los resultados y finalmente las conclusiones generales. El capítulo 7, conclusiones, presenta las lecciones aprendidas durante el desarrollo de esta tesis, las contribuciones hechas en este trabajo, las limitaciones que presenta y las mejoras que se pudieran hacer en trabajos futuros. El capítulo 8, anexos, contiene la bibliografía, el glosario de términos, detalles de código y experimentos.

CAPÍTULO 2 ESTADO DEL ARTE

En este capítulo, se presentan algunos artículos que como parte del estado del arte proporcionaron las bases para estudiar, abordar y obtener información sobre algunas de las técnicas utilizadas. Los artículos que aquí se presentan son los que se consideran los más importantes debido a que abordan temas tales como: la selección de la calidad de un producto dentro de la agroindustria, la compilación de reglas simbólicas a una red neuronal y la integración de conocimiento numérico y simbólico en un sistema híbrido neuro-simbólico.

2.1 Integración de aprendizaje simbólico y neuronal [Towell-1991] Este artículo describe un método para la combinación de los enfoques simbólicos y conexionistas en máquinas de aprendizaje. Se presenta un marco de trabajo de tres estados. El primer estado involucra la inserción de conocimiento simbólico dentro de redes neuronales, el segundo dirige el refinamiento de este conocimiento a priori en la representación neuronal, mientras que el tercero concierne a la extracción del conocimiento simbólico refinado. Descripción del problema Este artículo revisa algunas de las investigaciones que combinan el enfoque simbólico y redes neuronales para la inteligencia artificial y presenta un marco de trabajo para la combinación de los dos paradigmas (ver figura 2.1).

Figura 2.1: Marco de trabajo para la combinación de aprendizaje simbólico y neuronal.

Información simbólica

inicial

Red Neuronal inicial

Información simbólica final

Red Neuronal final

Insertar Extraer

Refinar (Aprendizaje)

Ejemplos

Capítulo 2 Estado del Arte

8

Técnica de solución La técnica utilizada para insertar conocimiento simbólico (primera fase) es KBANN (redes neuronales artificiales basadas en el conocimiento). Éste ha sido aplicado exitosamente perfeccionando las teorías del dominio para problemas del mundo real. Varios grupos han encontrado que las redes neuronales basadas en el conocimiento, entrenan más rápido que las redes neuronales “estándar” [Towell-1991]. Los experimentos sugieren que las redes basadas en el conocimiento generalizan mejor a nuevos ejemplos que las redes estándar. Para refinar el conocimiento insertado dentro de la red (segunda fase) existen dos formas:

(1) Utilizar métodos de aprendizaje simbólico e ideas para enfocar el ajuste de la red, en pesos y topología.

(2) Cambiar la RNA back-propagation para mejorar la naturaleza simbólica de un problema dado.

La tercera fase del marco de trabajo involucra la extracción de la información simbólica de una red entrenada. La extracción de las reglas puede ayudar a entender el aprendizaje de la “caja negra” que es la RNA. Algunas de las técnicas utilizadas para ello son: Reglas “NOFM”. Este algoritmo extrae reglas mientras mantiene la exactitud de la red entrenada. Requiere que los pesos se agrupen dentro de pocos grupos. Conclusión Este artículo es importante para el presente trabajo, debido a que en él se pueden observar representados dos tipos de enfoques, tanto el enfoque simbólico como el enfoque conexionista, los cuales se integran en un mismo marco de trabajo para poder ser mejorados. 2.2 Interpretación de redes neuronales artificiales: mapeando redes neuronales artificiales en reglas [Towell-1992] Este artículo propone un método para la extracción de reglas comprensibles a partir de redes neuronales. Este método opera en el contexto de un proceso de tres pasos para el aprendizaje que utiliza el dominio de reglas basadas en el conocimiento, en combinación con las redes neuronales. Las pruebas empíricas utilizando problemas del mundo real como el de la biología molecular, demuestran que las reglas de este método extraídas del entrenamiento de las redes neuronales son superiores a las reglas derivadas por un sistema de aprendizaje que refina directamente reglas simbólicas, y son aún más comprensibles para el experto.


9

Descripción del problema Las redes neuronales artificiales (RNAs) han probado ser una técnica poderosa y general para máquinas de aprendizaje. Sin embargo, tienen varias deficiencias bien conocidas. Quizás la más significativa de estas deficiencias es la dificultad a explicar el por qué una RNA entrenada toma una decisión en particular. Sin la habilidad para explicar sus decisiones, es difícil ser confiable en la formalidad de una red que dirige un problema del mundo real. Además, esta deficiencia hace difícil transferir la información aprendida por una red a la solución de los problemas relacionados. Por consiguiente, se han estado buscando métodos para la extracción de reglas simbólicas comprensibles a partir de las redes previamente entrenadas. Un enfoque para entender el entrenamiento de las redes es utilizar tres ligas en cadena. Este enfoque se ilustra en la figura 2.2.

Figura 2.2: Refinamiento de las reglas utilizando las redes neuronales artificiales.

La primer liga inserta el dominio del conocimiento dentro de una red neuronal utilizando KBANN (redes neuronales artificiales basadas en el conocimiento) [Towell-1991]. La segunda liga entrena la red utilizando un conjunto de ejemplos de entrenamiento clasificados y métodos de aprendizaje neuronales. La liga final extrae las reglas del entrenamiento de la red. El problema de la extracción de las reglas es determinar las situaciones en las cuales las reglas son verdaderas. Para ello, considere lo siguiente: si la suma de los pesos de las entradas excede el bias, entonces la activación de la unidad será cercana a uno, de lo contrario la activación será cercana a cero. Por lo tanto, los métodos de extracción de reglas buscan la forma en la cual la suma de los pesos de las entradas excede el bias, para considerar que la regla es verdadera [Towell-1991]. Técnica de solución Para la extracción de las reglas se utiliza el algoritmo NOFM. Esta técnica permite que una conclusión sea verdadera si se cumplen como verdaderos N atributos de un total de M. Este algoritmo consiste en las siguientes etapas:

(1) Con cada una de las unidades ocultas y de salida, se forman grupos de conexiones con pesos similares.

(2) Se colocan las conexiones de pesos de todos los miembros del grupo al promedio del grupo.

(3) Se elimina cualquier grupo que no afecta si la unidad será activa o inactiva.


10

(4) Se obtienen todas las conexiones de pesos constantes, optimizar bias (umbrales) de las unidades ocultas y de salida.

(5) Se forma una regla única para cada unidad oculta y de salida. (6) Donde sea posible, se simplifican las reglas para eliminar pesos y umbrales

superfluos. Conclusión Del estudio de este artículo, se puede dar cuenta que existen trabajos en los cuales se intenta refinar el conocimiento inicial y se puede obtener uno nuevo o mejorado. Éste artículo se consideró como uno de los más importantes, debido a que trata la inserción, refinamiento y extracción del conocimiento, aún cuando éste último no se aborde en este trabajo de tesis. La información presentada en éste artículo se diferencia del anterior, en que en éste se hace énfasis en la etapa de extracción, por lo tanto se tratan más a fondo los métodos utilizados para llevarla a cabo.

2.3 Máquina de aprendizaje constructiva: un nuevo enfoque neuro- simbólico [Osorio-2002] Recientemente se ha utilizado un sistema híbrido neuro–simbólico para combinar los logros de las redes neuronales artificiales (RNA) y los Sistemas simbólicos Basados en Conocimiento (SBC). Tales sistemas híbridos intentan tomar ventajas de la potencia de sus respectivos componentes. En este artículo se presenta el sistema INSS, un nuevo enfoque híbrido basado sobre los principios de las redes KBANN. Representa una importante mejora en comparación con su predecesor porque el aprendizaje y el proceso de extracción del conocimiento es más rápido y realizado en forma incremental. Descripción del problema El principal argumento, y el más utilizado, para justificar el estudio y la aplicación de los sistemas híbridos neuro-simbólicos es la complementariedad de los métodos simbólicos de la inteligencia artificial y los métodos conexionistas o sub-simbólicos (RNA). El sistema fue probado con las siguientes propiedades:

- Posibilidad de usar y tomar en cuenta varias clases de representación del conocimiento.

- Mejor eficiencia del sistema global cuando es comparado con cada uno de estos componentes.

- Fuerte acoplamiento entre los componentes. - Posibilidad de aprendizaje global.


11

Técnica de solución El sistema INSS está compuesto de cinco módulos: módulo simbólico, construcción de una red a partir de reglas, aprendizaje de la RNA y memoria, extracción de las reglas, y validación de las mismas. El sistema INSS presentado ofrece varias ventajas comparado con el sistema KBANN en el cual fue inspirado. INSS tiene una mejor ejecución y permite la extracción y adquisición incremental del conocimiento de la red. Además, está basado en un método de aprendizaje incremental ya utilizado en el desarrollo cognitivo del modelo humano. Este método de aprendizaje permite desarrollar un sistema perfectamente adaptado a los conceptos propuestos en el marco de trabajo de los sistemas de máquinas de aprendizaje constructivo. Conclusión El estudio de este artículo es importante ya que da un panorama general de las partes en que está dividido un sistema híbrido neuro-simbólico y permite ubicar al problema planteado dentro de la primer y segunda etapa (construcción de una RNA a partir de reglas y refinamiento o aprendizaje de la misma). 2.4 Sistema de visión artificial para el control de calidad del melón [Fuentes-2003] Este artículo presenta avances de un desarrollo el cual, mediante un sistema de visión artificial, realiza el proceso de selección de hortalizas, principalmente el melón, basándose en los estándares nacionales e internacionales para su posterior empaque. Descripción del problema Debido a las exigencias del mercado en cuanto a respetar los esquemas de control de calidad, se pretende mejorar los métodos de control de calidad para el empaque de melón y lograr satisfacer dichos estándares. Actualmente, el proceso de la verificación de la calidad incluye una etapa muy importante: la selección, la cual se realiza en forma manual y visual, lo cual implica una inversión de tiempo mayor. Por lo anterior, se propone un mecanismo de selección de melones a partir de estrategias computacionales de visión artificial y la automatización del proceso de selección y empaque. Las variables que son utilizadas en este sistema de visión artificial son las siguientes:

1. Tamaño 2. Textura 3. Color


12

Técnica de solución El sistema de selección de melones, consta de tres etapas:

1. Adquisición: se utiliza una cámara de video CCD o estado sólido RS 170 y una tarjeta de adquisición de video IMAQ 1400.

2. Proceso de segmentación: en esta etapa se definen los contornos que conforman

cada melón y aún cuando a través de la banda transportadora se junten dos melones se implementa un algoritmo de umbralización orientado a contornos utilizando la transformada de Hough [González-1996] que permite separar cada uno de los pixeles que conforman una imagen, lo cual evitará el empalme de objetos. Para calcular el nuevo umbral se analiza el histograma de las imágenes donde se encuentra el melón y en las que no lo hay.

3. Extracción. Una vez segmentado cada melón, se extraen sus características y se

comparan con las almacenadas en la base de datos en la cual se indica el tamaño estándar, la textura y el color. Para la determinación de los tamaños se generó un algoritmo que permite identificar los extremos de cada melón para medir su diámetro.

4. Clasificación. Con base en los datos aportados por la extracción, se efectúa la

clasificación o control de calidad que determinará la fruta que se asignará para el mercado de exportación, el mercado nacional y el mercado local; esto se realiza en tiempo real durante el proceso de transporte de la fruta antes de su empaque en cajas.

Conclusión Como ya se ha mencionado anteriormente, los sistemas de visión artificial se han dedicado a la tarea de reconocer los objetos dentro de nuestro entorno y este artículo es una muestra de este trabajo; sin embargo, como es posible ver en ningún momento se intenta integrar el conocimiento de un experto, por lo que esta tesis se diferencia de sistemas como éste, en donde en forma externa al SVA se tiene información que puede ser importante y que permite complementar la ya existente.


13

2.5 Otras referencias Symbolic state transducers and recurrent neural preference machines for text mining [Arevian-2003] Este artículo se centra en los traductores simbólicos y máquinas neuronales recurrentes para sustentar las tareas de extracción y clasificación de información textual. Estos traductores simbólicos y máquinas de aprendizaje neuronal pueden ser vistos como agentes independientes, cada uno abordando la misma tarea en una manera diferente. La combinación de estos en un sistema puede potencialmente ser más robusto, las fortalezas y las debilidades de los diferentes enfoques producen la complementariedad de conocimiento. A brief overview of hym: a methodology for the development of hybrid intelligent information systems [Kendal-2003] Este artículo presenta un caso especial en el contexto de integrar sistemas en donde un sistema de información tradicional y un sistema basado en conocimiento son requeridos. En este artículo se describe una metodología para el desarrollo de sistemas en el cual la arquitectura jerárquica consiste de tres niveles. Ésta metodología se ha sido aplicada para el desarrollo de un sistema para el diagnóstico de enfermos de vértigo. Knowledge transfer between neural networks, proceedings of the sixteenth european [Mcgarry-2002] El objetivo de la transferencia del conocimiento es tomar ventaja de la experiencia del entrenamiento anterior para resolver nuevas tareas. Este artículo aborda el tema de transferir el conocimiento entre las redes neuronales. Presenta un trabajo preliminar ilustrando cómo una red neuronal entrenada en una tarea puede ser utilizada para asistir en la síntesis de una nueva pero similar tarea. Hybrid preference machines based on inspiration from neuroscience. cognitive systems [Wermter-2002] Este artículo, bosqueja un marco de trabajo en el cual se centra en una integración híbrida de técnicas simbólicas y neuronales dirigiéndolas a cómo se pueden procesar conceptos de un nivel más alto basados en conceptos de neurociencia (en particular, procesamiento de lenguaje). Este es un marco de trabajo híbrido el cual permite una liga entre las redes neuronales, máquinas conexionistas y máquinas de estado finito simbólico. A hybrid medical information system for the diagnosis of dizziness [Rashad-2001] Éste artículo describe el desarrollo de un sistema de información híbrido real, desarrollado utilizando la metodología HyM y combinando componentes de un sistema de información tradicional con inteligentes o sistemas basados en conocimiento. El sistema para información médica híbrido, involucra varias actividades que a menudo ayudan a los hospitales. Este sistema fue desarrollado para ayudar en las actividades de los hospitales


14

incluyendo registro, diagnósticos, investigaciones, y para el diagnóstico de enfermos de vértigo. Aprendizado de máquinas: métodos para inserção de regras simbólicas em redes neurais artificiais aplicados ao controle em robótiva autônoma [Osorio-2001] Este trabajo tiene por objetivo presentar los métodos de inserción de reglas simbólicas en redes neuronales artificiales de tipo MLP con el objetivo de aumentar la ejecución del aprendizaje de estas redes. Principalmente este trabajo demuestra que se pueden crear redes neuronales con el poder del tratamiento de información equivalente o superior a los árboles de decisión. Este trabajo se aplica en problemas específicos de independencia robótica. Hybrid neural systems [Wermter-2000] Este artículo provee una introducción a los sistemas híbridos neuronales. Los sistemas híbridos neuronales son sistemas computacionales los cuales están basados principalmente en redes neuronales artificiales pero también permiten una interpretación simbólica o una interacción con componentes simbólicos.

Aplicaciones de la inteligencia artificial en problemas de producción [Vargas 2003]

Este documento está centrado en analizar más a fondo la inteligencia artificial con sus diferentes paradigmas, siendo las más relevantes: las redes neuronales, los algoritmos genéticos, los sistemas de lógica difusa y los autómatas programables, con sus diferentes aplicaciones en la vida cotidiana y más específicamente aplicados a las soluciones de problemas relacionados con la ingeniería industrial. Son muchos los estudios y aplicaciones que se han logrado con el desarrollo de esta ciencia, entre las cuales se tienen redes neuronales aplicadas al control de la calidad donde la red evalúa si determinado producto cumple o no con las especificaciones demandadas.

Operación automática de control de calidad usando un sistema de visión por computador [López-2000]

En este artículo se presenta una alternativa para la realización del control de calidad en la producción de empaques utilizados en compresores centrífugos, basándose en la implementación del sistema de visión artificial Robot Vision PRO, capaz de ejecutar de manera totalmente automática las labores de identificación de objetos y de control de calidad de los mismos. También se presenta el procedimiento seguido para la adquisición, procesamiento, reconocimiento y ejecución del control de calidad de la aplicación estipulada.

Full-color space image analysis of food products using the wingrain system [Locht-2000]

Desde el aspecto visual del alimento y de otros productos biológicos, en el juicio de la calidad, la inspección visual es una parte importante del control de calidad en estas


15

industrias. Esta inspección se ha realizado históricamente por medio de la única "herramienta" disponible, el ojo humano. La adquisición de datos, la evaluación automática y el control directo de las condiciones ambientales son posibles en un grado muy limitado, tal inspección es desperdiciadora de tiempo y costos intensivos. La necesidad del control de calidad visual conjuntamente con la automatización aumenta en todos los campos de la producción a una demanda para la evaluación automática y objetiva de parámetros visuales como tamaño, forma, la estructura, etc. Los sistemas de la visión en la forma de cámaras fotográficas, iluminación y computadoras proporcionan una solución que puede satisfacer esta demanda. Esta tecnología también se ha aplicado con éxito como herramienta imprescindible en detalles del semiconductor, la electrónica e industrias del transporte, utilizando imágenes a escala de grises.

2.6 Conclusiones y discusión En la actualidad existen grupos dedicados al estudio de los sistemas híbridos y los sistemas híbridos neuro-simbólicos, una muestra del trabajo de investigación en este campo son los artículos que se presentaron dentro del estado del arte. En ellos se puede observar el interés que se tiene en la integración de las reglas y la transferencia del conocimiento de un sistema a otro, de manera tal que al integrarse en un solo sistema, éste posea las ventajas de cada uno de los sistemas que lo integran. Algunas de las áreas en los cuales se han aplicado, son, la medicina y la neurociencia (procesamiento del lenguaje). En el estado del arte se puede constatar que existen trabajos en torno al reconocimiento de la calidad de productos que pretenden ayudar a la industria y más en específico en la agroindustria. Por lo que aún continúa la necesidad de contar con sistemas que apoyen en el reconocimiento de la calidad de un producto en específico.

CAPÍTULO 3 MARCO TEÓRICO El marco teórico está formado de los temas más relevantes involucrados en esta tesis. En primer lugar se presenta lo que se entiende por conocimiento y los tipos de conocimientos en los cuales está basado este trabajo. Una vez que se tiene claro lo que se entiende por conocimiento numérico y conocimiento simbólico en este contexto, es conveniente saber de dónde se obtienen. Para ello, en segundo lugar, se presenta el sistema de visión artificial y sus etapas; este tema es importante debido a que describe la forma en la cual se obtiene el conocimiento numérico del reconocimiento de un objeto. Para obtener el conocimiento simbólico se debe de tener una técnica. Es por eso que en tercer lugar se tiene la ingeniería del conocimiento, ya que, mediante el uso de sus técnicas, permite obtener el conocimiento simbólico. Una vez aclarado de dónde provienen los tipos de conocimiento tanto numérico como simbólico, se procede a estudiar los fundamentos de las redes neuronales artificiales, siendo éstas el tipo de estructura en la cual va a ser mapeado el conocimiento simbólico. Una vez mapeado el conocimiento simbólico a una red neuronal, es necesario conocer la forma en que éste será integrado junto con el conocimiento numérico, para ello, se estudian los sistemas híbridos neuro-simbólicos. Se concluye con una discusión sobre el tema. 3.1 Conocimiento Conocimiento: “Información almacenada o el modelo usado por una persona o máquina para interpretar, predecir y responder apropiadamente al mundo externo” [Reyes-1995]. Para que una persona pueda reconocer un objeto entre varios, es necesario que tenga el conocimiento de todos y cada uno de ellos. Todos poseemos una gran cantidad de conocimiento que desde pequeños se va adquiriendo. Este conocimiento está conformado tanto de ejemplos que representan a los objetos de nuestro entorno, así como de teoría que describe los rasgos o características de esos objetos. Si se pretende simular en una máquina el proceso de reconocimiento de un objeto, es importante saber los tipos de conocimiento que empleamos los seres humanos. Los sistemas de reconocimiento pueden ser utilizados, por ejemplo, en el de la calidad de

Capítulo3 Marco Teórico

17

algunos productos. Para ello, es necesario saber cómo el experto verifica la calidad de un producto para poder entonces simular este método de aprendizaje en una máquina. La inteligencia artificial siempre se ha preocupado por simular el comportamiento del ser humano, y aún cuando no se ha logrado alcanzar esta meta, no se detiene y trata de avanzar proponiendo algoritmos que permiten obtener resultados muy aceptables. La tecnología y la ciencia se han unido para obtener mejores resultados en la determinación de la calidad de un objeto. Este conocimiento del experto puede quedar almacenado para que posteriormente pueda ser utilizado y eventualmente mejorado. A continuación, se describe con más detalle los dos tipos de conocimientos comúnmente tratados por la inteligencia artificial: por un lado el conocimiento simbólico el cual se refiere principalmente a la teoría que se tiene sobre un objeto y por el otro lado el conocimiento numérico, el cual se refiere al conjunto de ejemplos que puede representar a ese mismo objeto. 3.1.1 Conocimiento simbólico El conocimiento simbólico es el conjunto de conocimientos teóricos que describen a un objeto en particular. Por ejemplo, desde niños se aprende a reconocer un objeto por el conjunto de características que lo conforman destacando aquellas características que lo hacen diferente de otros. La ventaja para describir objetos de manera simbólica, se convierte en una desventaja cuando se enfrenta a la situación en la cual la teoría no puede incluir todas las características que se encuentran en un objeto. Lo anterior se debe a que no se cuenta con toda la información necesaria para poder describir y reconocer a un objeto en todas sus modalidades, así como en diferentes contextos en los que se puede presentar. Por ejemplo, la descripción de una manzana Golden nos dice que “el fruto es grande y de color amarillo dorado, más largo que ancho, con la carne blanca amarillenta, fija, jugosa, perfumada y muy sabrosa. El pedúnculo es largo o muy largo y la piel delgada” [2]. Imagine que se toma esta definición para poder reconocer en un supermercado esta fruta. Si se enseña a un niño solamente esta descripción y se le pide que vaya a traer una manzana Golden, tal vez se corra con la suerte de que nos lleve la manzana correcta. Pero si en el supermercado esta manzana se encuentra mezclada o próxima a peras, se podría correr el riesgo de que eligiera una pera y no una manzana Golden, debido a que las dos frutas tienen una descripción muy próxima (ver figuras 3.1 y 3.2 ).

Figura 3.1: Manzana Goleen. Figura 3.2: Pera.


18

Por lo anterior, el contar con sólo conocimiento simbólico presenta el riesgo de no tener el conocimiento suficiente para realizar alguna tarea como por ejemplo el control de calidad. Por otra parte, este conocimiento simbólico puede ser adquirido por una persona ya sea por su experiencia, por sus estudios o de manera documental. Para que este conocimiento pueda ser utilizado en un sistema informático debe de tener cierta representación formal [Henao-1998]. Para ello, se tienen diferentes representaciones del conocimiento, entre las cuales se mencionan las siguientes:

1. Lógica proposicional. 2. Lógica de predicados. 3. Reglas de producción. 4. Árboles de decisión. 5. Redes semánticas. 6. Marcos. 7. Guiones. 8. Lenguajes orientados a objetos.

Una de las representaciones más comunes son las reglas de producción que describen cómo debe de hacerse una tarea, un proceso, o la descripción de un objeto para ser reconocido. 3.1.2 Conocimiento numérico Al igual que ocurre con el conocimiento teórico que se obtiene desde pequeños, también se tiene el conocimiento numérico que se aprende mediante la muestra de objetos a través de ejemplos (muchas veces ejemplos visuales), los cuales presentan a un objeto de diferentes formas para que éste sea reconocido posteriormente, independientemente de la escena en la que se encuentre. Continuando con la descripción de una manzana Golden, ahora imagine que se necesita describir a esta manzana presentando una base de imágenes de la fruta en diferentes posiciones, y con diferentes grados de calidad. En este caso, crear una base de imágenes lo suficientemente grande que pueda mostrar una manzana Golden en todos sus estados, posiciones, etc., para determinar que dicha fruta pueda ser una manzana de este tipo, sería muy complejo. Por lo anterior, la base de ejemplos creada a veces podría ser insuficiente para contemplar todos y cada uno de los casos en los que se pueda presentar una manzana [Reyes-2002]. Los sistemas de visión artificial, han trabajado para desarrollar sistemas que se encarguen de efectuar este reconocimiento mediante la adquisición y tratamiento de las imágenes [Reyes-2002]; sin embargo, este no es el objetivo de la presente tesis. El objetivo de este trabajo es obtener reglas a partir de fuentes tales como documentos, artículos o expertos humanos en el reconocimiento visual de las manzanas, mapear este conocimiento dentro de una RNA para posteriormente integrarlo con el conocimiento numérico proveniente de un sistema de visión artificial y finalmente obtener un conocimiento mejorado.


19

3.2 Sistema de visión artificial En la actualidad, diversos problemas de reconocimiento son resueltos con los sistemas de visión artificial, entre los cuales se encuentran la identificación de una persona, el reconocimiento de una firma, el reconocimiento de rostros [Magadán-1999], etc. Estos sistemas son bastante utilizados debido a que son capaces de simular el sistema de visión humano y hacerlo en una forma bastante precisa, apoyando al hombre en tareas donde el cansancio es el principal inconveniente. A continuación, se describen en forma breve las etapas que involucra un sistema de visión artificial. 3.2.1 Etapas de un sistema de visión artificial De acuerdo con [González-1996], un SVA consta de seis módulos (ver figura 3.3):

a) Adquisición de las imágenes. b) Preprocesamiento. c) Segmentación. d) Representación y descripción. e) Reconocimiento e interpretación y f) Base de conocimientos.

Figura 3.3: Módulos que constituyen un sistema de visión artificial [González-1996]. A continuación se describe brevemente en qué consiste cada una de estas etapas [González-1996].

a) Adquisición de imágenes: Son las técnicas que permiten obtener una imagen en un formato digital, para ello se utilizan cámaras digitales, video, scanners, etc.

b) Preprocesamiento: Tiene como objetivo el mejorar la imagen, de forma que se

aumenten las posibilidades de éxito en los procesos posteriores. Por ejemplo: mejorar el contraste, eliminar el ruido y aislar regiones cuya textura indica la probabilidad de información alfanumérica.

Segmentación Representación y descripción

Reconocimiento e interpretación

Preprocesamiento

Adquisición de imágenes

Base de conocimientos

Escena del mundo real

Resultado


20

c) Segmentación: Consiste en dividir una imagen de entrada en sus partes constituyentes u objetos.

d) Representación y Descripción: La representación es importante para transformar

los datos de píxel en bruto en alguna forma adecuada para ser posteriormente tratados por la computadora. También es necesario un método que resalte los rasgos de interés. La descripción o selección de rasgos consiste en extraer rasgos con alguna información cuantitativa de interés o que sean fundamentales para diferenciar una clase de objetos de otra.

e) Reconocimiento e Interpretación: El reconocimiento es el proceso que asigna una

etiqueta a un objeto basándose en la información proporcionada por sus descriptores. La interpretación implica dar un significado a un conjunto de objetos reconocidos.

f) La interacción con la base de conocimientos: Una parte importante del SVA es la

base de conocimientos (BC), la cual es el medio de comunicación e interacción con los otros módulos. De su correcta codificación dependerá el adecuado funcionamiento de todo el SVA. De acuerdo con el esquema de la figura 3.3 cada uno de los módulos del SVA se comunica con la base de conocimientos. En esta base, el conocimiento está codificado de una manera simple (por ejemplo detallar las regiones de una imagen donde se sabe que se ubica información de interés), o de una manera compleja, como una lista interrelacionada de todos los posibles defectos en un problema de inspección de materiales o una base de datos que contenga imágenes de satélite de alta resolución de una región.

3.3 Ingeniería del conocimiento Para poder obtener el conocimiento debe existir un método que permita la adquisición del mismo. Preocupados por tener métodos y técnicas surge la ingeniería del conocimiento la cual es una disciplina que nació en la década de los 1970’s junto con el desarrollo de los sistemas expertos, los sistemas basados en conocimiento y los sistemas de información intensivos en conocimiento [Henao-1998]. 3.3.1 Qué es la ingeniería del conocimiento Ingeniería del conocimiento: “es el proceso de elicitar, estructurar, formalizar y operacionalizar la información y el conocimiento involucrado en la resolución de problemas de un dominio, con el objetivo de construir un programa que pueda realizar la tarea de forma adecuada” [5]. La ingeniería del conocimiento se ha relacionado con el desarrollo de sistemas de software por computadora en los que el conocimiento y el razonamiento tienen un papel primordial. Para que la ingeniería del conocimiento logre alcanzar sus objetivos, ésta debe de incluir tareas tales como: adquisición del conocimiento, la representación del conocimiento y la


21

manipulación/validación del mismo. La persona encargada de la construcción y puesta en marcha de un sistema inteligente es el Ingeniero del Conocimiento (IC). Según Ama Hart [Hart-1992] “el IC debe tener ciertas habilidades entre las cuales están las siguientes: herramientas de comunicación, inteligencia con mente abierta, tacto y diplomacia, empatía y paciencia, persistencia, versatilidad e inventiva, conocimiento del dominio y conocimientos de sis temas inteligentes”. Otras personas que se encuentran involucradas son: el experto en el dominio, que proporciona el “saber cómo” (know how), los usuarios y los interesados en el desarrollo del proyecto. 3.3.2 Adquisición del conocimiento El conocimiento puede provenir de dos tipos de fuentes diferentes [Henao-1998]:

o Fuente de conocimiento estática o secundaria: Ésta es rígida en cuanto a que su contenido no se puede variar. Ejemplos de esta fuente son los libros, revistas, artículos, películas, etc.

o Fuente de conocimiento dinámica o primaria: Refleja las características del

conocimiento tales como la variabilidad, lo que implica que éste puede ser cambiante e inexacto. El experto humano sería un ejemplo de una fuente de conocimiento dinámica.

La adquisición del conocimiento permite extraer el conocimiento de fuentes estáticas y dinámicas y dependiendo de su tipo se siguen los procedimientos apropiados. 3.3.3 Adquisición del conocimiento de una fuente estática El ingeniero del conocimiento y el experto deben tener un vocabulario común para que logren una comunicación efectiva y eficiente. Esto solamente se consigue una vez que el ingeniero del conocimiento ha adquirido conocimientos del dominio del experto mediante libros, revistas, etc., y cuando el experto del dominio, ha obtenido el conocimiento relacionado con los fundamentos de los sistemas basados en el conocimiento. Para la obtención del conocimiento estático primero se seleccionan las fuentes más apropiadas relacionadas con el problema evaluando todos los recursos que se tengan disponibles. Por lo regular, el experto en el dominio proporciona algunos consejos acerca de qué fuentes estudiar. Posteriormente, se procede a realizar un estudio minucioso de dichas fuentes para que el ingeniero del conocimiento pueda adquirir ese conocimiento básico y fundamental del dominio del experto y así realizar posteriormente un proceso de adquisición eficiente y eficaz. 3.3.4 Adquisición del conocimiento de una fuente dinámica Una vez que el ingeniero del conocimiento realizó la tarea de adquirir el conocimiento básico del dominio (conocimiento estático) se procede a la adquisición del conocimiento de un fuente dinámica, donde la idea es que tanto el IC como el experto deberán de ser capaces


22

de expresar el conocimiento que tienen acerca del dominio del problema y precisar las actividades o procesos mentales que el experto realiza para llegar a una conclusión. El IC debe de llevar a cabo con mucho cuidado esta tarea para que pueda extraer el conocimiento heurístico que servirá al sistema, es decir las reglas que son utilizadas por el experto en el dominio. Además, al IC no se le permite cuestionar al experto si está haciendo lo correcto o no. Los cuestionarios, pláticas, entrevistas, etc., son una forma de obtener las ideas. Esta estrategia posibilita la extracción del conocimiento. 3.3.5 Representación del conocimiento La representación del conocimiento según [Bench-1990], “es una serie de convenciones sintácticas y semánticas que hacen posible describir las cosas. En donde la sintaxis es aquello que especifica una serie de reglas para combinar símbolos de tal forma que se formen expresiones válidas. La semántica es la especificación de cómo tales expresiones son interpretadas”. En esta tarea el IC toma el conocimiento extraído de las fuentes estáticas y dinámicas y lo lleva a una forma entendib le por el ingeniero del conocimiento y posteriormente por la herramienta de software. Inicialmente, el IC debe hacer la representación en papel para llevarla posterio rmente al computador. La elección de la forma más apropiada es un problema complejo. Algunas representaciones estándar para los sistemas de conocimiento son: lógica proposicional y lógica de predicados, reglas de producción, redes semánticas, marcos (frames), guiones (scripts), los lenguajes orientados a objetos, entre otros. Es en esta fase donde se construye la base de conocimientos del sistema. 3.3.6 Validación del conocimiento Una vez representado el conocimiento, éste debe ser validado tanto por el ingeniero del conocimiento como por el experto del dominio, asegurando que el conocimiento adquirido represente el conocimiento proporcionado por el experto. Por último, se evalúa el conocimiento del sistema por medio de pruebas de casos reales, confrontando ambos conocimientos entre sí. 3.4 Redes neuronales artificiales Desde su inicio, la inteligencia artificial ha tenido un gran interés en la solución de problemas complejos desarrollando sistemas que le permitan simular los mecanismos mediante los cuales el ser humano llega a resolver dichos problemas.


23

El hombre por sí mismo es un sistema complejo, y simular todos y cada uno de los subsistemas que lo forman sería una tarea muy difícil. Una de las áreas de la inteligencia artificial que se ha interesado mucho en el estudio de los procesos de funcionamiento del cerebro es el de las Redes Neuronales Artificiales (RNA). El objetivo de las RNA’s es simular el funcionamiento del cerebro humano a partir del comportamiento básico de las neuronas durante las etapas de aprendizaje y de reconocimiento [4]. Una RNA puede ser utilizada para resolver problemas relacionados con el reconocimiento de formas o patrones, la predicción, el control y la optimización, entre otras cosas. 3.4.1 La RNA vista desde el modelo biológico Las RNA’s están inspiradas en la estructura y funcionamiento de los sistemas nerviosos, siendo la neurona el elemento fundamental. Una neurona biológica está formada de un cuerpo celular más o menos esférico, de 5 a 10 micras de diámetro [4], de donde sale una rama principal llamada axón, así como varias ramas cortas conocidas como dendritas. La forma de comunicación entre las neuronas es a través de las dendritas y el cuerpo celular, los cuales reciben señales de entrada. El cuerpo celular combina estas entradas integrándolas y emitiendo por último la salida. El encargado de transmitir las señales es el axón a través de las terminales axónicas, las cuales distribuyen esta información hacia otro nuevo conjunto de neuronas. Las señales pueden ser de dos tipos: eléctrica y química. Donde la primera es generada por la neurona y transportada a través del axón, la segunda se transmite entre los terminales axónicos de una neurona y las dendritas de la otra. 3.4.2 Elementos de una Red Neuronal Artificial Para comprender el funcionamiento de las RNA es necesario que se conozcan los elementos fundamentales de ellas. A continuación se definen dichos elementos [4].

1. Unidad de proceso: Existen tres tipos de unidades; de entrada, de salida y oculta. Las primeras reciben señales desde el entorno, las segundas envían la señal hacia fuera de ese entorno, y las últimas se encuentran en el interior del sistema, permitiendo el paso de la señal que va desde la unidad de entrada hasta la unidad de salida.

2. Estado de activación. Los valores de activación pueden ser continuos o discretos. Si

se trata de valores discretos toman un conjunto de valores binarios, donde un estado activo se indica con un 1 y un estado pasivo se indica mediante un cero, y para el caso de valores continuos se consideran valores de -1 y 1 ó de 0 a 1, u otra convención.


24

3. Función de salida. Con cada unidad existe una función de salida, la cual transforma el estado actual de activación en una señal de salida. Por mencionar algunas funciones tenemos: escalón, lineal, mixta, sigmoidal y gaussiana.

4. Conexiones entre neuronas. Las conexiones de una RNA tienen asociado un peso

numérico, el cual al ser ajustado permite que la red aprenda. La entrada neta que recibe una neurona es la suma del producto de cada señal individual multiplicada por el valor de la sinapsis que conecta ambas neuronas.

5. Regla de aprendizaje. Se dice que en el cerebro humano el conocimiento se

encuentra codificado en las sinapsis. En las RNA el conocimiento es encontrado en los pesos de las conexiones entre neuronas. Todo proceso de aprendizaje implica cambios en estas conexiones. Así la RNA se dice que aprende en el momento de estabilizar los valores en sus pesos.

3.4.3 Estructura de la RNA Las neuronas dentro de la RNA se encuentran distribuidas formando niveles o capas de un número determinado de ellas. Estas capas pueden ser de entrada, de salida u ocultas (ver figura 3.4).

Figura 3.4: Niveles o capas en una RNA.

Se dice que una red es de propagación hacia adelante cuando ninguna salida de las neuronas es también entrada de neuronas ya sea del mismo nivel o de niveles precedentes. Por ejemplo la red neuronal de Kohonen. Una red es de propagación hacia atrás, cuando las salidas son conectadas como entradas de neuronas de niveles precedentes o de su mismo nivel. Por ejemplo la red neuronal Backpropagation. 3.4.4 Características de las RNA Algunas de las características más importantes en una RNA son las siguientes:

1. Topología de las RNA. La organización de las neuronas y la formación de las mismas en capas, definen la arquitectura de una red neuronal artificial. Los parámetros que intervienen en la red, son: número de capas, número de neuronas en cada capa, el grado de conectividad y el tipo de conexión.

Capa de salida

Capa oculta

Capa de entrada


25

2. Mecanismo de aprendizaje. El aprendizaje se define como el proceso por el cual una red neuronal modifica sus pesos en respuesta a una información de entrada. Existe aprendizaje supervisado y no supervisado. En el primer caso existe un agente externo o supervisor que controla el aprendizaje de la red, mientras que en el segundo no existe dicho supervisor.

En el aprendizaje supervisado el agente externo realiza un entrenamiento controlado donde él determina la respuesta que debería generar la red a partir de una entrada determinada. Este tipo de aprendizaje puede realizarse de cualquiera de las siguientes tres formas:

o Aprendizaje por corrección de error: Ajusta los pesos en función de la diferencia entre los valores deseados y los obtenidos en la salida de la red, conocido este tipo de aprendizaje como la función del error.

o Aprendizaje por refuerzo: El papel del supervisor se limita a indicar

mediante una señal de refuerzo si la salida obtenida en la red se ajusta a la deseada es decir si tuvo éxito o fracaso.

o Aprendizaje estocástico: Consiste básicamente en realizar cambios

aleatorios en los valores de los pesos de las conexiones de la red y evaluar su efecto a partir del objetivo deseado.

En el aprendizaje no supervisado no existe un instructor que determine si la salida obtenida es correcta o no, por lo que existen diferentes interpretaciones en torno a su salida. En este caso se aplican algoritmos de clustering.

3. Representación de la información de entrada y salida: Las redes neuronales

pueden ser clasificadas en función de la forma en que se representan las informaciones de entrada y las respuestas o datos de salida. Cuando tanto los datos de entrada como de salida son de naturaleza analógica, las funciones de activación de las neuronas pueden ser continuas, del tipo lineal o sigmoidal. Cuando admiten valores discretos o binarios a su entrada, y generan respuestas en la salida de tipo binario, las funciones de activación de las neuronas son de tipo escalón. Existe también un tipo de redes híbridas en las cuales las informaciones de entrada pueden ser valores continuos, aunque las salidas de la red son discretas.

3.4.5 Ventajas de las RNA Las siguientes son algunas de las ventajas que ofrecen las RNA:

1. Aprendizaje adaptativo: Capacidad de aprender a realizar tareas basadas en un entrenamiento.

2. Autoorganización: Haciendo uso de su capacidad de aprendizaje adaptativo las

redes neuronales artificiales organizan la información que reciben durante el aprendizaje y/o la operación.


26

3. Tolerancia a fallos: A diferencia con otros sistemas computacionales tradicionales, si se produce un pequeño fallo en la RNA no se produce una caída repentina. Por ejemplo en el caso de que exista ruido al momento de reconocer patrones, o que estos estén distorsionados o incompletos, aún con esto las redes pueden aprender y continuar realizando su función aunque se tenga cierta degradación.

4. Operación en tiempo real: Las computadoras neuronales pueden ser realizados en

forma paralela, para ello se diseñan y fabrican máquinas con hardware especial para lograr esta capacidad.

3.5 Sistemas híbridos neuro-simbólicos Un sistema híbrido está formado por la integración de varios subsistemas inteligentes, donde cada uno mantiene su propio lenguaje de representación y un mecanismo diferente de inferir soluciones. La finalidad de la implementación de los sistemas híbridos es mejorar la eficiencia y la potencia de razonamiento así como la expresión de los sistemas inteligentes. Los sistemas híbridos tratan de mejorar la forma de desarrollar sistemas y construir mecanismos más potentes, utilizando menos esfuerzo que el necesario para generar un sistema basado en un solo sistema inteligente. Los sistemas híbridos tienen potencial para resolver algunos problemas que son muy difíciles de afrontar utilizando un único método de razonamiento. Estos sistemas también podrían utilizarse para aprender los mecanismos cognitivos y modelos que utilizan algunos sistemas naturales. Un sistema híbrido inteligente, como por ejemplo los neuro-simbólicos, permiten integrar diferentes técnicas de representación y razonamiento en el mismo. Estos sistemas permiten utilizar información obtenida de varias fuentes. Los sistemas neuro–simbólicos pueden manejar información numérica y simbólica más efectivamente que los sistemas que individualmente lo hacen [Fernández-2000]. Los sistemas híbridos tienen las siguientes ventajas:

o Explotan todo el conocimiento disponible con respecto a la aplicación de un problema;

o Mezclan diferentes tipos de información (simbólica, numérica, inexacta e

imprecisa);

o Mejoran la ejecución total y eliminan las debilidades de los métodos aplicados individualmente.

o Crean sistemas de razonamiento robustos.


27

Medsker y Bailey [Medsker-1992] definen cinco modelos de integración (ver figura 3.5) donde SS representa a los sistemas simbólicos y SC a los sistemas conexionistas.

Figura 3.5: Modelos de hibridación en los sistemas [Medsker-1992].

A continuación, se dará una breve explicación de cada uno de ellos, en orden de menor a mayor integración. 3.5.1 Modelos independientes Se caracterizan por la utilización de varios sistemas inteligentes de forma paralela sin interacción entre ellos. Estos sistemas son utilizados en las siguientes situaciones:

o Necesidad de comparación de la eficacia y la eficiencia con la que dos sistemas de inteligencia artificial diferentes resuelven el mismo problema.

o Verificación de una solución dada por un sistema inteligente con otra proporcionada

por un mecanismo diferente.

o Construcción de prototipos de forma rápida en paralelo con la intención de crear una aplicación sólida. Tal vez el uso de dos técnicas puede resultar redundante. Sin embargo, al desarrollar una técnica después de otra es una buena forma de validar la primera. El utilizar dos técnicas en paralelo es una forma de integración muy débil que a veces simplifica la tarea de implementación del sistema.

3.5.2 Modelos transformacionales

Se comienza a resolver un problema utilizando un modelo inteligente y se termina utilizando otro. Por ejemplo se puede presentar la situación en la cual al inicio se piensa que la mejor solución para resolver un problema es la utilización de una red neuronal artificial, durante el transcurso de la implementación se decide que un sistema experto puede proporcionar una solución más adecuada puesto que incluye ciertas características de la red neuronal.

Modelos integrados totalmente

Modelos fuertemente acoplados

Modelos ligeramente acoplados

SS SC

SS SC

SS SC

Modelos independientes Modelos transformacionales

SC SS SS SC


28

Algunas ventajas de este modelo son las siguientes: o El modelo transformacional facilita una implementación más rápida que el modelo

anterior, y posteriormente sólo requiere el mantenimiento del sistema inteligente. o El desarrollo del sistema final se realiza con la técnica apropiada.

Sin embargo, también se cuenta con ciertas limitaciones:

o Sistemas totalmente automatizados para transformar un sistema experto en una red

neuronal y viceversa, son difíciles de implementar. o Si se requieren grandes modificaciones en un sistema, es muy probable que sea

necesario un nuevo desarrollo desde el principio. o El sistema final está limitado por las capacidades del modelo seleccionado

finalmente. 3.5.3 Modelos ligeramente acoplados

Este tipo de integración es una auténtica forma de integración de los sistemas inteligentes. Permite la interacción entre sistemas inteligentes con diferentes características de formas muy diversas.

Preprocesador. Una red neuronal artificial se puede utilizar como un procesador de datos de entrada que realice funciones de modificación, selección, etc., de los datos antes de introducirlos a un sistema experto.

Postprocesador. Los resultados obtenidos por un sistema experto se pueden enviar a una red neuronal artificial por medio de un archivo. En este caso el sistema experto puede realizar funciones de manipulación de datos, clasificación, selección, control, etc., y la red neuronal se encarga de hacer predicciones, análisis de datos, etc. Coprocesador. Necesita la comunicación bilateral entre los dos o más sistemas que forman parte del híbrido, permitiendo un comportamiento de cooperación entre, por ejemplo, una red neuronal y un sistema experto. Interfaz de usuario. Una red neuronal artificial se puede utilizar para facilitar la interacción entre un usuario y un sistema experto.

Algunas limitaciones de los modelos anteriores son las siguientes:

o El tiempo de operación de los sistemas es elevado.

o El desarrollo de sistemas inteligentes separados con posibilidades de comunicación entre ellos, conlleva una duplicación de esfuerzos.


29

3.5.4 Modelos fuertemente acoplados Aquí la información se comparte entre los sistemas inteligentes por medio de estructuras residentes en la memoria, y no por medio de archivos de datos externos, lo que incrementa la capacidad de interacción entre sistemas y mejora la eficacia del modelo visto anteriormente. Se puede utilizar en los cuatro submodelos presentados: preprocesador, postprocesador, coprocesador e interfaz de usuario. 3.5.5 Modelos totalmente integrados Los distintos sistemas inteligentes que lo forman, comparten las estructuras de datos y la representación de los mismos. La comunicación entre los diferentes submódulos se efectúa utilizando la naturaleza dual (conexionista y simbólica) de las estructuras de datos. Existen varios sistemas que utilizan esta forma de razonar y que incluyen redes neuronales, sistemas expertos, nodos de entrada y salida y diferentes tipos de mecanismos de control. Los sistemas expertos conexionistas son un ejemplo de ellos. Algunas ventajas de este modelo son:

o El producto final es robusto y sólido.

o Mejora la capacidad de resolución de problemas.

o Durante el desarrollo del sistema no exis te redundancia.

o Mejora la capacidad de adaptación, generalización, tolerancia al ruido, justificación y deducción lógica con respecto a sistemas no integrados.

Algunas limitaciones para este modelo son:

o Relativas al aumento en la complejidad del modelo. o Dificultad de construcción de herramientas que elaboren estos híbridos de forma

automática.

o La validación, verificación y mantenimiento de estos sistemas requiere más trabajo.


30

3.6 Discusión En este trabajo de tesis, el conocimiento simbólico es obtenido de fuentes de conocimiento tanto estáticas como dinámicas. Para obtener el conocimiento simbólico de la fuente dinámica fue necesario entrevistar al experto humano, mientras que el conocimiento numérico fue obtenido de bases de ejemplos (de imágenes y de datos). El tipo de representación del conocimiento simbólico que se utiliza son las reglas de producción, éstas son mapeadas a una estructura de red neuronal donde posteriormente se integran con el conocimiento numérico en un SHNS. El SHNS de este trabajo se considera que está basado en un modelo totalmente integrado ya que como se mencionó, este modelo permite una comunicación de naturaleza dual (conexionista y simbólica).

Segmentación Representación y Descripción

Reconocimiento e Interpretación

Pre-procesamiento

Adquisición de imágenes

Base de Conocimientos

Escena del mundo real

Resultado

Conocimiento Externo

CAPÍTULO 4 MODELO CONCEPTUAL DEL COMPILADOR SIMBÓLICO (CompSimb) En este capítulo se muestra, de manera general, el modelo conceptual del compilador simbólico (CompSimb), comenzando por los principios en el cual está basado, continuando con la arquitectura de la herramienta en donde paso a paso se describe cómo se realiza el mapeo de las reglas a una RNA, y finalmente una explicación del manejo de la interfaz del usuario. El sistema fue desarrollado en el lenguaje de programación C++ Builder versión 5.0, ya que es un lenguaje muy utilizado en el ambiente computacional. 4.1. Principios en los que se basó CompSimb Bajo el principio de los SHNS, se decidió crear un sistema que pudiese ayudar a los sistemas de visión artificial (ver capítulo 3, sección 3.2), complementando el conocimiento numérico que se tiene para la verificación de la calidad de algún producto con el conocimiento simbólico que puede provenir de una fuente externa (ver figura 4.1); ya sea el conocimiento empírico de un experto humano o el conocimiento adquirido por medio de libros y revistas.

Figura 4.1: Integración del conocimiento externo en un SVA.

Capítulo 4 Modelo conceptual del sistema

32

Adquisición del conocimiento (Experto/Ingeniero en

conocimiento)

Transferencia del Conocimiento

Reglas Inserción

Reglas

Extracción

Módulo Simbólico

Módulo Neuronal

Reglas Ejemplos Módulo de Validación

Conocimiento Teórico Conocimiento Práctico

La investigación en el campo de los sistemas híbridos trata de mejorar la forma de desarrollar sistemas y construir mecanismos más potentes, utilizando menos esfuerzo que el necesario para generar un sistema basado en un solo sistema inteligente [Corchado, 1999]. Para este trabajo, es necesario unificar dos tipos de representación del conocimiento en un SHNS, ver figura 4.2, en esta figura se observa la arquitectura general de esta clase de sistemas, estos sistemas explotan la capacidad para utilizar al mismo tiempo el conocimiento teórico (conjunto de reglas simbólicas) y el conocimiento práctico (conjunto de ejemplos observados), estos dos sistemas son ejemplos del modo de integración en los sistemas híbridos, permitiendo la transferencia del conocimiento bi-direccional entre los módulos simbólico y conexionista [Osorio-2002].

Figura 4.2: Dos tipos de representación unidos en un SHNS [Osorio-2002].

El primer sistema que se utiliza es un sistema basado en conocimiento (SBC), el cual permite que las reglas que describen los criterios de calidad de las manzanas (ver capítulo 5), sean traducidas o compiladas a reglas simples IF – THEN, las cuales son cercanas a nuestro lenguaje natural. La segunda herramienta, la RNA, participa en el refinamiento de las reglas simbólicas utilizando para ello el conocimiento simbólico y el conocimiento numérico (ver capítulo 3). Esta RNA está basada en los principios de KBANN [Towell-1991] y de INSS [Osorio-1998]. La parte sombreada en la figura 4.3 indica las etapas de desarrollo en esta tesis, centrando nuestra atención en la etapa de compilación (ver figura 4.4) la cual se encarga de traducir un conjunto de reglas a una RNA, para posteriormente integrar este conocimiento simbólico junto con el conocimiento numérico.


33

Experto Humano

Reglas Simbólicas

RNA Inicial

Base de Ejemplos (numéricos)

RNA Refinada

Reglas Refinadas

Compilación Reglas ->RNA

Módulo de integración numérico - simbólico Explicitación

RNA ->Reglas

Validación de reglas existentes

Reglas Finales

P R O B L E M A D E C O N T R O L D E C A L I D A D

Validación de nuevas reglas

Sistema de Visión Artificial (SVA)

Figura 4.3: Etapas de un sistema híbrido neuro-simbólico completo [Reyes-2003].

Figura 4.4: Esquema general del sistema de traducción de reglas simbólicas a una RNA (CompSimb). La traducción de reglas a RNA (compilación) es llevada a cabo mediante un mapeo o relación entre un conjunto de reglas y una RNA. Este mapeo se puede observar en la tabla 4.1 en la cual se observa cómo es que se realiza la traducción de un conocimiento simbólico de base a una topología de RNA.

ENTRADA AL SISTEMA NEURO-SIMBÓLICO

COMPILACIÓN

ARCHIVO DE REGLAS

SIMBÓLICAS ANÁLISIS LÉXICO ANÁLISIS SINTÁCTICO

TABLA DE SÍMBOLOS

MAPEO DE REGLAS SIMBÓLICAS A UNA

RED NEURONAL

GENERACIÓN DE LOS ARCHIVOS DE PESOS Y

TOPOLOGÍA

-Creación de las unidades de entrada. -Creación de las unidades de salida.

-Creación de las unidades ocultas.

-Creación de las conexiones entre las unidades.

-Asignación de pesos. -Etiquetado y retiquetado de las unidades.

CompSimbb


34

Tabla 4.1: Correspondencia entre el conocimiento simbólico de base y la RNA. Debido a que la parte de compilación es la parte medular de esta tesis, a continuación se presenta la arquitectura de la herramienta, describiendo paso a paso la forma en la cual se construyó la herramienta CompSimb y los algoritmos que fueron utilizados para su construcción. 4.2. Arquitectura de la herramienta Esta sección presenta la forma en la cual se implementó en nuestro sistema la inserción del conocimiento simbólico dentro de una RNA. Se incluye el algoritmo utilizado, el pseudo código y las herramientas que hicieron posible el desarrollo y la implementación del sistema CompSimb, el cual está inspirado en [Towell-1991]. 4.2.1 Mapeo de las reglas a la RNA El mapeo de reglas a una RNA consiste en la creación de una topología y la definición de los pesos. La topología de la red neuronal artificial, pretende representar el conjunto de reglas que describen a un caso de estudio dentro de una RNA. Los pesos en la RNA se encargan de definir las dependencias que existen entre un antecedente y un consecuente. Los tipos de características y las reglas deben de tener cierta notación, para ello la sección 4.2.1.1 contiene una especificación completa de la información aceptada por el sistema. 4.2.1.1 Representación simbólica: atributos y reglas Para poder traducir nuestro conocimiento base a una red neuronal, es necesario tener en cuenta dos conjuntos de información. En primer lugar, se tiene el conjunto de atributos que se utilizan para describir a un objeto, por ejemplo una manzana. En segundo lugar, se necesita el conjunto de reglas que codifican nuestro conocimiento base. A continuación se describe la forma en la cual el sistema desarrollado acepta esta información. 4.2.1.2 Tipos de atributos Los atributos deben tener la siguiente forma:

(Nombre_atributo Tipo_atributo Valor_atributo)

Conocimiento simbólico RNA Conclusiones finales Unidades de salida Datos de soporte Unidades de entrada Conclusiones intermedias Unidades ocultas Dependencias Pesos y conexiones


35

Donde: Nombre_atributo.- Es una etiqueta que identifica el nombre de la característica (ejemplo: tamaño, color, categoría). Tipo_atributo.- Puede ser uno de los siguientes tipos: Nominal: una lista de nombres (ejemplo: CategoríaI, CategoríaII). Binaria: valores de F o V (Falso ó Verdadero). Lineal: valores numéricos o continuos. Ordenados: valores que tienen cierto ordenamiento. En_Rango: valores continuos que van de un valor mínimo a uno máximo. Valor_atributo.- Cada característica tiene valores permitidos. Algunos ejemplos de los tipos de atributos se muestran a continuación. 1. Variable nominal: Este es el tipo de característica más simple. Todos los posibles valores de la característica son nombradas. Por ejemplo, los posibles valores para el nombre de una manzana podría ser dado mediante: (manzana nominal (Golden, Red, Gala)) Este tipo de característica se traduce en tres unidades dentro de la red neuronal. 2. Variable binaria: Las características de binarias son una subclase especial de características nominales que toman solamente dos valores (F o V). Lo siguiente es una característica binaria: (temperatura- es- caliente binaria (F V)) Para este caso se crea una sola unidad. 3. Variable lineal: Las características lineales tienen valores numéricos, en este caso los valores van a ser representados mediante subrangos. Normalmente estos valores son continuos, pero cualquier característica puede ser descrita utilizando una característica lineal. Por ejemplo, la siguiente característica describe el precio de una taza en términos de tres subrangos. (precio lineal ((precio bajo 0 3) (precio medio 3 7) (precio alto 7 10))) Para este caso, se crea una unidad por cada subrango.


36

4. Variable ordenado : Es un tipo especial de característica nominal para lo cual los valores son totalmente ordenados. Como en las características nominales, las características de tipo ordenado son manejadas creando una unidad de entrada para cada uno de los valores posibles. (clasificación nominal (categoríaI, categoríaII, categoríaIII)) 5. Variable en rango: Este es similar al tipo de variable lineal, con la diferencia de que existe un solo valor para ese atributo, creándose una sola unidad. (color_rojo rango (105 184)) La traducción correspondiente a los atributos de entrada según sea su tipo a una RNA, se puede observar en las figuras 4.5 y 4.6.

Tallo : BINARIO: V/F; Color_rojo : RANGO: [30, 80];

Figura 4.5: Traducción de atributos de tipo binario y de tipo rango en la RNA.

El ejemplo de la figura 4.5 muestra las unidades que se crean a partir de los atributos especificados como entrada. En este caso se tienen dos atributos: Tallo el cual es el nombre que se le da al atributo de tipo binario y Color_rojo el cual es el nombre que se le da al atributo de tipo rango, creándose una unidad para representar a cada uno de estos atributos.

Categoría : NOMINAL: uno, dos, tres.

Figura 4.6: Traducción de atributos de tipo nominal/continuas en la RNA.

UNIDAD NOMINAL / CONTINUAS

Categoria#uno Categoria#dos Categoria#tres

UNIDAD BINARIA

Tallo Color_rojo

UNIDAD RANGO


37

El ejemplo de la figura 4.6 muestra las unidades que se crean a partir del atributo especificado como entrada de tipo nominal llamado Categoría. Como se podrá observar, en este caso se crean tres unidades para cada uno de los valores que puede tomar el atributo Categoría. 4.2.1.3 Tipos de reglas Así como los atributos tienen una cierta sintaxis, las reglas también tienen un formato el cual se presenta a continuación:

(indicador consecuente antecedente1 antecedente2…antecedente n)

Ejemplo: Buena_manzana :- tamaño(grande), manzana_golden, tallo(V)..antecedente n. donde los consecuentes o antecedentes pueden tomar una de las siguientes formas

(valor_característica) o nombre Ejemplo: Manzana_golden:- En_rango(Color_R, 123, 159), En_rango(Color_G, 103, 203), En_rango(Color_B, 111, 180); Buena_manzana :- tamaño(grande), Manzana_golden. En el caso de los antecedentes a una regla, la primera forma es normalmente empleada cuando se refiere a una unidad de entrada, y la segunda forma es empleada cuando hace referencia a una conclusión intermedia. Para el ejemplo anterior, la conclusión intermedia se referie al nombre Manzana_golden, y la unidad de entrada se refiere al tamaño, cuyo valor es grande. Antecedentes Las funciones siguientes son permitidas en los antecedentes de las reglas.

Nombre_Arch_Ent1 Valores permitidos en la función Función_C2 MAYOR_QUE Solamente para características continuas y lineales GT MENOR_QUE Solamente para características continuas y lineales LT MAYOI3 Solamente para características continuas y lineales GTOE MENOI3 Solamente para características continuas y lineales LTOE EN_RANGO Solamente para características lineales IN IGUAL Solamente para características lineales EQUAL NO Niega un antecedente, maneja variables nominales NOT

1 Nombre_Arch_Entra: Es el nombre utilizado en el archivo simbólico de entrada. 2 Función_C: Es el nombre que el compilador reconoce internamente. Por ejemplo: La función Mayor_Que será reconocida por el compilador como GT. 3 MAYOI, significa mayor o igual. MENOI, significa menor o igual.


38

En estas funciones se utilizan dos valores importantes: sensibilidad y confianza. El valor de sensibilidad, ajusta la curva de la salida de las unidades y el valor de confianza, permite ajustar el error aceptado en la salida de las unidades (valores proporcionados por el usuario en el sistema). A continuación se describen cada una de estas funciones4 [Osorio-1998]. 1.1. Mayor_Que (Entrada, ValCte) La unidad que representa esta función será activada si el valor de la variable de “entrada” es superior al valor constante “ValCte” especificado como parámetro de esta función. Una variante de esta función es la función Mayor_o_igual_que donde la salida de la unidad será activada si la variable de “entrada” es igual o superior al valor constante “ValCte”. Las dos funciones son reconocidas por el compilador: GT y GTOE. El valor de peso y de su bias se determina mediante: Pesos_GT(E,V) = Sensibilidad Bias_GT(E,V) = -1.0*(ValCte-Confianza)*Sensibilidad Donde: E = Entrada V = Valor de la entrada Ejemplo1: GT(precio,100) Se traduce como: precio debe ser mayor que 100 pesos. Ejemplo2:

GTOE (precio, 100)

Se traduce como:

precio debe ser mayor o igual que 100 pesos. 1.2. Mayor_Que (Entrada1, Entrada2) La unidad que representa esta función será activada si el valor de la variable de “entrada1” es superior al valor de la variable de “entrada2”. Una variante de esta función es la función Mayor_o_igual_que donde la salida de la unidad será activada si la variable de “entrada1” es igual o superior al valor de “entrada2”. Las dos funciones son reconocidas por el compilador: GT y GTOE. El valor de los pesos y de su bias se determina mediante: 4 Estas funciones son las utilizadas por INSS [Osorio-1998].


39

Peso1_GT(E1,E2) = Sensibilidad Peso2_GT(E1,E2) = -1.0 * Sensibilidad Bias_GT(E1, E2) = Confianza * Sensibilidad Donde: E1 = Entrada uno E2 = Entrada dos Ejemplo1: GT(calificación_dos, calificación_dos) Se traduce como: Calificación_dos debe ser mayor que calificación_uno. Ejemplo2:

GTOE (calificación_dos, calificación_dos)

Se traduce como:

Calificación_dos debe ser mayor o igual que calificación_uno. 2.1. Menor_Que (Entrada, ValCte) La unidad que representa esta función será activada si el valor de la variable de “entrada” es inferior al valor constante “ValCte” especificado como parámetro de esta función. Una variante de esta función es la función Menor_o_igual_que donde la salida de la unidad será activada si la variable de “entrada” es inferior o igual al valor constante “ValCte”. Las dos funciones son reconocidas por el compilador: LT y LTOE. El valor de peso y de su bias se determina mediante: Pesos_LT(E,V) = -1.0 * Sensibilidad Bias_LT(E,V) = (ValCte + Confianza) * Sensibilidad Ejemplo1: LT(temperatura, 30) Se traduce como: temperatura debe ser menor que 30ºC . Ejemplo2:

LTOE (temperatura, 30)


40

Se traduce como:

temperatura debe ser menor o igual que 30ºC

2.2. Menor_Que (Entrada1, Entrada2) La unidad que representa esta función será activada si el valor de la variable de “entrada1” es inferior al valor de la variable de “entrada2”. Una variante de esta función es la función Menor_o_igual_que donde la salida de la unidad será activada si la variable de “entrada1” es inferior o igual al valor de “entrada2”. Las dos funciones son reconocidas por el compilador: LT y LTOE. El valor de los pesos y de su bias se determina mediante: Peso1_LT(E1,E2) = -1.0 * Sensibilidad Peso2_LT(E1,E2) = Sensibilidad Bias_LT(E1, E2) = Confianza * Sensibilidad Ejemplo1: LT(presión, temperatura) Se traduce como: presión debe ser menor que temperatura . Ejemplo2:

LTOE (presión, temperatura)

Se traduce como:

Presión debe ser menor o igual que temperatura 3. En_Rango (Entrada, ValCte1, ValCte2) La unidad que representa esta función va a ser activada si el valor de la variable de entrada “Entrada1” está comprendida en el intervalo especificado por los valores constantes “ValCte1” “ValCte2”. Esta función es realizada utilizando la combinación de dos unidades “Si GT(Entrada, ValCte) y LT (Entrada, ValCte2) está En_Rango(Entrada, ValCte1,ValCte2) es verdadera. Esta función es reconocida por el compilador como IN. Las tres unidades que componen a esta función En_Rango son definidas como sigue: Unidad GT(Entrada, ValCte1): Pesos_GT(E,V)=Sensibilidad Bias_GT(E,V)= -1.0*(ValCte1-Confianza)*Sensibilidad


41

Unidad LT(Entrada, ValCte2): Pesos_LT(E,V) = -1.0 * Sensibilidad Bias_LT(E,V) = (ValCte2 + Confianza) * Sensibilidad Unidad IN(GT,LT): Peso1_GT(E,V) = WF Peso2_LT(E,V) = WF Bias_Et (E, V) = -1.5 * WF Donde: WF = factor_de_peso. Ejemplo1: IN(temperatura, 25, 30) Se traduce como: La temperatura debe estar en el rango entre 25 y 30. 4.1. Igual (Entrada, ValCte) La unidad que representa esta función va a ser activada si el valor de la variable de entrada “Entrada” es igual al valor constante especificado por “ValCte”. La función igual está realizada utilizando la combinación de dos unidades: “si GT(Entrada, ValCte) y LT(Entrada, ValCte) es igual (Entrada, ValCte) es verdadera” o bien Si En_Rango(Entrada, ValCte, ValCte) es igual(Entrada,ValCte)”. Las tres unidades que componen la función EQUAL reconocida por el compilador son definidas como sigue: Unidad GT(Entrada, ValCte): Pesos_GT(E,V)=Sensibilidad Bias_GT(E,V)= -1.0*(ValCte-Confianza)*Sensib ilidad Unidad LT(Entrada, ValCte): Pesos_LT(E,V) = -1.0 * Sensibilidad Bias_LT(E,V) = (ValCte + Confianza) * Sensibilidad Unidad EQUAL(GT,LT): Peso1_GT(E,V) = WF Peso2_LT(E,V) = WF Bias_Et (E, V) = -1.5 * WF


42

Ejemplo1: EQUAL(temperatura, 25) Se traduce como: La temperatura debe ser igual a 25. 4.2. Igual (Entrada1, Entrada2) La unidad que representa esta función va a ser activada si el valor de la variable de entrada “Entrada1” es igual al valor de la variable de “Entrada2”. La función igual está realizada utilizando la combinación de dos unidades: “si GT(Entrada1, Entrada2) y LT(Entrada1, Entrada2) es igual (Entrada1, Entrada2) es verdadera”. Las tres unidades que componen la función EQUAL son definidas como sigue: Unidad GT(Entrada1, Entrada2): Peso1_GT(E1,E2) = Sensibilidad Peso2_GT(E1,E2) = -1.0 * Sensibilidad Bias_GT(E1, E2) = Confianza * Sensibilidad Unidad LT(Entrada1, Entrada2): Peso1_LT(E1,E2) = -1.0 * Sensibilidad Peso2_LT(E1,E2) = Sensibilidad Bias_LT(E1, E2) = Confianza * Sensibilidad Unidad EQUAL (GT,LT): Peso1_GT(E,V) = WF Peso2_LT(E,V) = WF Bias_Et (E, V) = -1.5 * WF Ejemplo1: EQUAL (temperatura, presión) Se traduce como: La temperatura debe ser igual a la presión. 5.No(Entrada (valor)) La unidad que representa esta función va a ser activada si el valor de la variable de entrada “Entrada” es negado. Su peso será de –WF o WF según sea activada o nó.


43

B:- C,D. B:- E,F,G.

Reglas iniciales Reglas finales

B:- B’. B:- B’’. B’:-C, D. B’’:- E,F,G.

R E E S C R I B I R

Ejemplo1: NOT(cielo(soleado)) Se traduce como: Si no esta cielo soleado entonces no es un buen día. Dado que puede ocurrir que en un conjunto de reglas exista la misma función más de una vez, por ejemplo: Cat_I :- EN_RANGO(Defectos_Moteado,0 , 0); Cat_IV :- EN_RANGO(Defectos_Moteado,0.1 , 2.5). Se deben de crear tantas unidades sean las correspondientes a cada una de las funciones, aún cuando se trate del mismo atributo que se encuentre involucrado en la función ya que de no hacerse así, el bias se duplicaría y causaría conflicto en la estructura de la red neuronal. 4.2.1.4 Algoritmo de traducción de reglas a RNA Para llevar a cabo el mapeo de reglas a RNA se implementó el siguiente algoritmo [Towell-1991]:

1. Reescribir las reglas. 2. Mapeo de las reglas a una RNA. 3. Determinación del nivel. 4. Agregar las ligas entre las unidades. 5. Mapear unidades de entrada no utilizadas en las reglas.

1.- Reescribir las reglas El primer paso del algoritmo consiste en traducir el conjunto de reglas dentro de un formato el cual aclara la estructura jerárquica y hace posible traducir directamente las reglas dentro de una red neuronal. Este paso involucra el verificar que un consecuente sea el mismo para uno o más antecedentes. Si existe más de un antecedente a un consecuente, entonces cada consecuente con más de un antecedente, será reescrito. Por ejemplo, véase la figura 4.7 en la cual se observa la reescritura de dos reglas que tienen un mismo consecuente. Para ello las reglas de producción iniciales son escritas en notación prolog.

Figura 4.7: Reescribiendo las reglas con un mismo consecuente.


44

Donde: :- significa Si.. , significa un y Por lo tanto, nuestra primera regla inicial es B:- C, D, donde C y D son antecedentes, premisas, condiciones o situaciones y B es el consecuente, conclusión, acción o respuesta se lee de la siguiente forma:

Si C y D son verdaderas, entonces B es verdadera.

Nuestra segunda regla inicial B:- E, F, G se lee de la siguiente forma: Si E y F y G son verdaderas, entonces B es verdadera.

Debido a que nuestras dos reglas iniciales les corresponden el mismo consecuente, éstas deben ser rescritas para poder ser traducidas a la RNA y aclarar como se menciona anteriormente, la estructura jerárquica de la RNA. Por lo tanto, las reglas finales como se observan en la figura 4.7 quedan de la siguiente forma: B’ se cumple si C y D son verdaderas. B’’ se cumple si E, F, G son verdaderas. B se cumple si B’ ó B’’ es verdadera. Cuando los antecedentes son iguales como por ejemplo las reglas B:- C, D. y X:- C, Z. el antecedente representado por la letra C no será necesario ser reescrito. 2.- Mapeo de las reglas a una RNA El siguiente paso del algoritmo consiste en un mapeo entre un conjunto transformado de reglas y una red neuronal. Para ello, la figura 4.8 muestra la correspondencia existente entre un conocimiento simbólico de base y la red neuronal. Los pesos son colocados a –w o w2 dependiendo si el antecedente es negado o no. Towell propone que el valor de peso por default sea de -4 o 41 respectivamente [Towell-1991]. El bias es colocado a –w/22 en el caso de reglas disyuntivas y (–2P-1/2)*w5 si se trata de reglas conjuntivas.

5 Según [Towell-1991] en el capítulo 2 de su tesis se explica los teoremas empleados para llegar a estas fórmulas.


45

Red neuronal

Figura 4.8: Muestra la correspondencia entre el conocimiento base y la red neuronal. Tomando el ejemplo de la figura 4.7 donde nuestras reglas finales quedaron de la siguiente forma:

B:- B’. B:- B’’. B’:-C, D. B’’:- E,F,G.

Si se desea mapear estas reglas a una RNA queda como se muestra en la figura 4.9. El lado izquierdo de la figura, muestra la forma en la cual las reglas quedan representadas dentro de una estructura jerárquica dentro la RNA. El lado derecho de esta figura, muestra las fórmulas mediante las cuales el bias es calculado dependiendo de la forma que presente la regla. En el caso de las reglas B’:- C, D y B’’:- E, F, G las unidades que representan a B’ y B’’ el bias deberá ser calculado mediante la fórmula (-2P-1/2)*w ya que se tratan de reglas conjuntivas, en cambio, las reglas B:- B’ y B:- B’’ para la unidad que representa a B el bias deberá ser calculado mediante la fórmula –w/2 ya que se trata de una disyunción. Los pesos serán colocados como ya se mencionó anteriormente, dependiendo si el antecedente es negado –w de lo contrario, será colocado como w.

Figura 4.9: Mapeo de reglas a una red neuronal y las fórmulas aplicadas en la misma.

Base del conocimiento

Conclusiones finales

Conclusiones intermedias

Atributos

Red Neuronal

Unidad de salida

Unidades ocultas

Unidades de entrada

B

C D E F G

B’ B’’ (–2P-1/2)*w

–w/2

w

(–2P-1/2)*w

C D E F G


46

2

2

1

1

1 2

1

1

Unidades de entrada

3

1

2

1 2

1

1

4

Unidades de entrada

Figura 4.10: Nivel determinado mediante el nivel mínimo de una

unidad de entrada.

Figura 4.11: Nivel determinado mediante el nivel máximo de una unidad de

entrada.

3.- Determinación del nivel (distancia de una unidad oculta a una unidad de entrada) El nivel puede ser definido en alguna de las siguientes formas:

o Número de nivel mínimo que existe entre la unidad interna a una unidad de entrada. Un ejemplo de esto se muestra en la figura 4.10.

o Número de nivel máximo que existe entre la unidad interna a una unidad de

entrada6. Un ejemplo de esto se muestra en la figura 4.11. El nivel utilizado para este trabajo es el que se muestra en la figura 4.11. 4.- Agregar las ligas entre unidades En este paso se agregan las ligas que unen las unidades que representan los atributos no existentes en las reglas a las unidades de salida (ver figura 4.12 cuadro 6). 5.- Mapear atributos de entrada no existentes en las reglas Es esta parte se incrementan las características de entrada no contempladas en las reglas pero que fueron especificadas por el usuario dentro del archivo simbólico, de manera tal que este conjunto de características de entrada sean compatibles con el conjunto de atributos especificados en la base de datos numérica (ver figura 4.12 cuadro 6). En la figura 4.12 se muestra un ejemplo que resume los cinco pasos anteriores. El número de la izquierda corresponde al paso dentro del algoritmo. Pasos del algoritmo:

6 Según [Towell-1991] ésta fue la utilizada para determinar el número de nivel, por lo tanto para efectos de hacer compatible este trabajo se decidió tomarlo de la misma forma.


47

A:- B,Z. B:- C,D. B:- E,F,G. Z:- Y, not X. Y:- S,T. (1)

A:- B,Z. Z:- Y, not X. B:- B’. Y:- S,T. B:- B’’. B’:-C, D. B’’:- E,F,G. (2)

A B Z B’ B’’ Y C D E F G S T X

3

2 2

1 1 1

(4)

(5) (6)

(3)

0. En el cuadro número (1), se muestra el conjunto de reglas escritas en una notación

PROLOG.

1. Como en el cuadro anterior se detectó que dos reglas tenían un mismo consecuente, en este paso se procede a llevar a cabo la reescritura de las reglas quedando como se muestra en el cuadro número (2).

2. El cuadro número (3) se muestra una representación gráfica de las reglas, mostrando

la estructura jerárquica de las mismas.

3. En el cuadro número (4) muestra el mapeo de la estructura jerárquica para la creación de la red neuronal.

4. En el cuadro número (5) se muestra la determinación del nivel mediante la longitud máxima que tiene una unidad a una entrada.

5, 6. Finalmente el cuadro (6) muestra las unidades agregadas a la red neuronal, representadas en la figura por medio del círculo gris.

Figura 4.12: Ejemplo de la traducción de reglas a una red neuronal.


48

4.2.2 Pseudo código de traducción de reglas a red neuronal A continuación se presenta la lógica empleada para realizar la traducción de las reglas simbólicas a una red neuronal artificial. El símbolo (;) indica una línea de comentario. Sea: U un vector para las unidades con los siguientes campos Ligas : inicialmente un vector vacío Numero_Reglas: inicialmente 0 Bias: inicialmente 0 Nivel: inicialmente 0 Nombre: ningún valor R: Es una lista de reglas. F: una lista de características. ;; Primero crear todas las unidades de entrada ∀(f ∈F) ∀(v ∈ < valores de F >) crea una unidad U con U: nombre =f.v U: nivel =1 ;;A continuación crear las unidades ocultas y de salida, creando una unidad que ;;corresponde a cada consecuente y antecedente único dentro del conjunto de reglas. ;;También ligar cada consecuente con sus antecedentes e incrementar el bias de cada ;;consecuente con la suposición que la regla es conjuntiva. Se asume que todas las reglas ::disyuntivas con más de un antecedente fueron originalmente reescritas. ∀(r∈R) Sea Ur la unidad con nombre Ur.nombre = <consecuente de r> If (Ur no existe entonces crearla) ∀(a ∈ <antecedentes de r> ) Sea Ua la unidad con Ua.nombre = a If(Ua es un antecedente de función y ya existe, entonces crear las unidades correspondientes) If(Ua no existe entonces crearla) Crea una liga desde Ua hasta Ur con peso w Agregar w a Ur.bias ;;Ahora ajusta el bias de cada unidad tal que para reglas conjuntivas será de (2P-1/2)*w ;;o w/2 para unidades disyuntivas.


49

INICIO DEFINE ATRIBUTOS FIN_ATRIBUTOS REGLAS FIN_REGLAS ATRIB_ADIC_USUARIO INCLUIR FIN

ORDENADO RANGO CONTINUO BINARIO V/F NOMINAL

MENOR_QUE (LT) MENOI (LTOE) MAYOR_QUE (GT) MAYOI (GTOE) IGUAL (EQUAL) EN_RANGO (IN) NO (NOT)

TIPO DE FUNCIÓ N TIPO DE ATRIBUTO GENERAL

4.2.3 Diseño y compilación del archivo simbólico en el sistema En esta etapa, se procede a diseñar el archivo de entrada a nuestro sistema. Las palabras reservadas (o tokens), los símbolos utilizados, y los bloques que diferencian una información de otra, son algunos de los aspectos a tratar en el diseño de nuestro archivo de entrada. Para respetar cierta gramática, se debe de tener un compilador gramatical que permita revisar nuestro archivo (etapa previa al compilador simbólico). Para ello, el sistema ANTLR [Terence-2003] fue utilizado para la compilación del archivo simbólico. Este sistema se encarga de lo siguiente: Desarrollo del parser. Consiste en la producción de las reglas que definen la estructura del archivo simbólico. Desarrollo del lexer. Se encuentra conformado de los símbolos (o tokens) de los cuales el parser hará uso para validar la estructura del archivo. Generación de los archivos .cpp. En esta etapa se generaron archivos tanto del parser como el del lexer que podrán ser utilizados con C++ Builder 5.0. Compilación del archivo simbólico. Una vez que el archivo simbólico fue llamado y compilado desde C++ Builder 5.0. Los símbolos y palabras reservadas empleadas que deberá utilizar el parser son las mostradas en las figuras 4.13 y 4.14.

Figura 4.13: Simbología empleada en el archivo de entrada.

Figura 4.14: Palabras reservadas empleadas en el archivo de entrada.

Símbolo Traducción // Comentario # Inicio y fin de un proceso , Representa la conjunción :- Representa el Si… ; Fin de una sentencia . Fin de una cláusula : Separación entre la variable, tipo y valor, en la definición de los atributos.


50

A continuación se muestra un ejemplo del archivo de reglas:

//Archivo simbólico: prototipo.simb

#INICIO

#ATRIBUTOS

defectos_alarg_partiduras : BINARIO: V/F;

defectos_moteado : BINARIO: V/F;

defectos_varios : BINARIO: V/F;

tallo : BINARIO: V/F;

color_rojo : RANGO : [100 149];

color_verde : RANGO : [37 52];

color_azul : RANGO : [18 52].

#FIN_ATRIBUTOS

#REGLAS

Manzana_Golden:- EN_RANGO(color_rojo, 100 149), EN_RANGO(color_verde, 37 52),

EN_RANGO(color_azul, 18 52);

Sin_defectos :- tallo(V), defectos_alargados_partiduras(F),

defectos_varios(F), defectos_moteado(F);

Calidad_Extra :- Manzana_Golden, Sin_defectos.

#FIN_REGLAS

#FIN

Como se podrá observar cada atributo está declarado con su tipo y su valor dentro de la sección de atributos. Un ejemplo de la forma en la cual se deben de interpretar las reglas es la siguiente: Regla 1: Manzana_Golden:- EN_RANGO(color_rojo, 100 149), EN_RANGO(color_verde, 37 52), EN_RANGO(color_azul, 18 52);


51

Se interpreta como:

Si el color rojo se encuentra en el rango de 100 y 149 y el color verde se encuentra en el rango de 37 y 52 y el color azul se encuentra en el rango de 18 y 52 entonces es una Manzana_Golden.

Regla 2:

Sin_defectos :- tallo(V), defectos_alargados_partiduras(F),

defectos_varios(F), defectos_moteado(F);

Se interpreta como:

Si tiene presencia del tallo, y no tiene defectos alargados partiduras y no tiene defectos varios y no tiene defectos de moteado entonces Sin_defectos.

Regla 3:

Calidad_Extra :- Manzana_Golden, Sin_defectos.

Se interpreta como:

Si es una manzana Golden y no tiene defectos entonces se conc luye que tiene calidad extra.

4.3. Interfaz del usuario En esta sección se pretende que el usuario del sistema conozca el funcionamiento del mismo. La pantalla principal consiste de varios menús, se explicará cada uno de ellos con su respectivo ejemplo. a).- Menú de archivo: Este menú se encarga de las acciones tales como: 1.- Abrir el archivo desde la ruta en la cual se encuentre el archivo simbólico. 2.- Compilar el archivo, es decir, verificar que el archivo de entrada sea correcto de acuerdo a la gramática especificada. 3.- Modificar el archivo, en caso que el archivo no sea correcto, el activar esta opción le da la oportunidad de modificar los errores desde el sistema. 4.- Guardar las modificaciones, una vez que el archivo haya sido modificado, esta opción permitirá guardar las últimas modificaciones en el archivo para ser nuevamente compilado.


52

5.- Salir, lo cual permitirá abandonar el sistema cerrando nuestra interfaz. Ejemplo: En primer lugar, se ejecuta el archivo CompSimb.exe, inmediatamente aparecerá la pantalla de inicio (ver figura 4.15).

Figura 4.15: Pantalla principal del sistema CompSimb.

Se procede a cargar el archivo simbólico desde el directorio donde se localiza, seleccionando el archivo con el menú archivo/abrir (ver figura 4.16).

Figura 4.16: Carga del archivo simbólico en el sistema.


53

Una vez que se ha cargado el archivo en la pantalla y en la memoria, se procede a ejecutar la compilación para verificar que se esté cumpliendo con la sintaxis especificada mediante ANTLR. Para ello se debe seleccionar el menú archivo/compilar. Si el archivo está correctamente escrito, entonces no aparecerá ningún mensaje en la ventana inferior Resultado de la compilación del archivo simbólico, además de que en la pantalla Resultado de Compilación indicará un 0 en la sección de Errores, incluyendo la ruta donde se encuentra el archivo, el número de reglas y el número de atributos especificados (ver figura 4.17).

Figura 4.17: Archivo correctamente compilado por el sistema ANTLR. En caso que el archivo esté incorrecto, entonces aparecerán los mensajes de error [Terence-2003] en la ventana inferior Resultado de la compilación del archivo simbólico además de que los atributos y las reglas no se mostrarán en la parte derecha. Si este último caso sucede, entonces se tiene que corregir el archivo simbólico. Esto se puede hacer mediante la opción archivo/modificar donde se pueden hacer nuestras modificaciones desde pantalla. Una vez realizadas las modificaciones se deben guardar las modificaciones mediante la opción archivo/guardar_modificaciones para nuevamente llevar a cabo la compilación archivo/compilar. Después de que el archivo es correctamente compilado, se visualizan en la parte derecha los atributos especificados en nuestro archivo simbólico así como el tipo y el valor de los mismos. También se muestran las reglas donde se visualizan su consecuente y sus respectivos antecedentes (ver figuras 4.18 y 4.19).


54

Figura 4.18: En la parte derecha, dentro de la pestaña Atributos se visualizan los atributos del archivo

simbólico.

Figura 4.19: En la parte derecha, dentro de la pestaña Reglas se visualizan las reglas del archivo simbólico.

b).- Menú RNA: Se encarga básicamente de la compilación del archivo simbólico a la RNA. Este menú a su vez tiene las siguientes secciones: 1.- Parámetros de compilación, dentro de esta opción se deben de especificar los parámetros de la compilación tales como sensibilidad y confianza para cada una de las funciones, así como el valor de Factor de Peso (WF).


55

2.- Compilación, esta opción se encarga de compilar el archivo simbólico a la RNA, creando los archivos *.wts, *.top y *.rep. Continuando con el ejemplo anterior, antes de pasar a la compilación de las reglas a la red neuronal, se tienen que especificar una serie de parámetros en el menú RNA/parámetros de compilación, entre los cuales se tienen las opciones de compilación, el factor de peso, el valor de sensibilidad, el valor de confianza, etc., (ver figura 4.20) a continuación se da una breve descripción de estos parámetros. Opciones de compilación: Se tienen como opciones de compilación PT y PTA, la primera consiste en que durante la compilación se crean los archivos de pesos (P) y de topología (T). La segunda consiste en crear esos mismos archivos pero con la opción de colocar un factor de peso en forma aleatoria (A). Factor de peso (w): En esta parte, se tiene la posibilidad de asignar el factor de peso deseado. El factor de peso asignado por default es de 4.0 [Osorio-1998]. Valor de sensibilidad: El parámetro de ‘sensibilidad’ permite ajustar la pendiente de la curva obtenida a la salida de las unidades que representan las funciones. El valor de sensibilidad es un valor de entrada positivo igual o superior a 1.0. Valor de confianza: El parámetro ‘Confianza’ permite ajustar el error aceptado a la salida de las unidades que representan las funciones descritas. El valor de confianza debe ser un valor positivo igual o superior a 0.0. El valor de sensibilidad y confianza son especificados para cada una de las funciones permitidas dentro de los antecedentes (ver sección 4.2.2.2). También en esta pantalla se tiene dos opciones más que conciernen a la especificación de los parámetros de sensibilidad y confianza. En la parte inferior se encuentra Colocar estos valores a todas las funciones o Personalizar. La primera opción quiere decir que los valores que usted coloque en la primera función serán los mismos para todas las funciones. La segunda opción le permitirá colocar los valores de sensibilidad y confianza en cada una de las funciones, incrementando o decrementando su valor.


56

Figura 4.20: Muestra la pantalla de opciones de compilación.

Una vez que se especificaron los parámetros de compilación, se procede a realizar la compilación de las reglas a la red neuronal. Para ello, se debe de elegir la opción de RNA/compilación que automáticamente creará el mapeo de reglas a red neuronal, guardándose además en archivo la topología y los pesos. En pantalla se pueden ver las reglas reetiquetadas y un mensaje de fin de la compilación lo que indica que la compilación se ha efectuado (ver figura 4.21)

Figura 4.21: Muestra el fin de la compilación de reglas a red neuronal. c).- Menú Ver: Este menú consiste de dos opciones:


57

1.- Archivos: esta opción permite que se puedan visualizar en pantalla los archivos *.top y *.wts, y crear un archivo de resumen de la RNA, así como la opción de impresión en papel de dicha información. 2.- Interfaz: esta opción fue creada para llevar a cabo nuestras pruebas de integración del conocimiento simbólico con el numérico se debe de entrar en modo MS-DOS para poder ejecutar el sistema simulador neuronal Neusim [Osorio-2002] y llevar a cabo la tarea de integración más fácilmente (ver figura 4.23) Al elegir Ver/Archivos/Topología o Ver/Archivos/Pesos se visualiza en pantalla los archivos *.top y *.wts (ver figura 4.22).

Figura 4.22: Archivos *.top a la derecha y *.wts a la izquierda de la pantalla. La descripción de estos archivos se hace en las secciones 4.3.1 y 4.3.2.

Figura 4.23: Interfaz creada para llevar a cabo la integración desde modo MS -DOS. d).-Menú Ayuda: esta opción proporciona información acerca del sistema CompSimb.


58

4.3.1 Descripción del archivo de topología La siguiente es la descripción del formato del archivo de salida *.top $Red Neuronal Núm_Entradas Núm_Salidas Núm_Capas Núm_Neuronas $Conexiones % Especificación de las conexiones de entrada I (input): % Las entradas de “ex” hasta “ey” son conectadas a “nx” hasta “ny” % Las entradas y las neuronas son numeradas a partir de cero I ex ey nx ny I ex ey nx ny ... Ejemplo 1:

I 0 0 0 0 Esto quiere decir que la neurona de entrada 0 esta conectada a la neurona oculta 0 y nada mas. Ejemplo 2:

I 0 0 01 Esto quiere decir que la neurona de entrada 0 esta conectada a la neurona oculta 0 y 1. % Especificación de las conexiones de las neuronas N (neuron): % Las neuronas de “ni” hasta “nj” son conectadas a “nx” hasta “ny” N ni nj nx ny N ni nj nx ny … Ejemplo 1:

N 1 1 2 2 Esto quiere decir que la neurona oculta N 1 esta conectada a la neurona oculta 2 y nada mas. Ejemplo 2:

N 1 2 22 Esto quiere decir que las neuronas ocultas N 1 y 2 estan conectada a la neurona oculta 2 y nada mas.


59

Ejemplo 3:

N 1 2 2 3 Esto quiere decir que las neuronas ocultas 1 y 2 estan conectadas a las neuronas ocultas 2 y 3. % Especificación de las neuronas de salida O (output): % Las neuronas de “nx” hasta “ny” son de neuronas de salida O nx ny O nx ny … Ejemplo 1:

O 10 10 Esto quiere decir que la neurona de salida O es la unidad 10. $Etiquetas NeuronaX “Nombre_de_la_unidad” NeuronaY “Nombre_de_la_unidad” … Ejemplo 1:

0 cateroria Esto quiere decir que se etiqueta la neurona cero con el nombre de categoría $Entradas EntradaX “Nombre_de_la_entrada” EntradaY “Nombre_de_la_entrada” … Ejemplo 1:

0 tallo Esto quiere decir que se etiqueta la neurona de entrada cero con el nombre de tallo $Fin


60

4.3.2 Descripción del archivo de pesos A continuación se dará una descripción del formato del archivo de salida *.wts Núm_Entradas Núm_Salidas Núm_Capas Núm_Neuronas B Neurona Freeze_Flag Tipo_función Bias ... N Neurona_Origen Neurona_Destino Valor_del_Peso … I Entrada_Origen Entrada_Destino Valor_del_Peso … Fin Freeze_Flag: Indica si es una neurona con pesos congelados. Tipo_función: Indica el tipo de función de activación de la unidad. El valor de 0 indica una función de tipo sigmoide. Bias: Valor del bias de la unidad.

CAPÍTULO 5 CASO DE ESTUDIO Diariamente compramos productos alimenticios tales como carnes, frutas, verduras y lo hacemos de forma tal que juzgamos la calidad de los mismos por la apariencia que éstos presentan. Sin embargo, generalmente no se piensa demasiado si tales productos cuentan con los requerimientos suficientes para poder llevarlos del campo a los comercios, y mucho menos si cumplen con los estándares establecidos por la organización que los regula. Este capítulo tiene como objetivo dar una introducción al caso de estudio “Calidad en las frutas: el caso de las manzanas” que es utilizado como ejemplo de aplicación en el desarrollo de la tesis. En este capítulo se hablará de aspectos generales de la calidad en productos agrícolas con especial énfasis en las frutas, profundizando posteriormente en las manzanas; la importancia que tiene la verificación de la calidad de las mismas, y la forma en que la calidad está ligada con la seguridad de los productos que se consumen diariamente. Finalmente, se hace un desglose del conjunto de características que se tomaron en cuenta para la formulación de las reglas, provenientes de documentos y del experto humano especialista en la calidad de las manzanas. Se comenzará con el concepto de calidad en los alimentos, ya que a partir de éste se obtuvieron los atributos que formaron parte de las reglas que el experto humano utiliza. 5.1 Calidad en los alimentos: el caso de las frutas Según la Organización Internacional para la Estandarización [Symons-2002], la calidad se define como “la totalidad de las características y rasgos de un producto relacionados con su capacidad para satisfacer necesidades explícitas o implícitas”. Si el producto en cuestión cumple con los requisitos demandados por los consumidores, compradores, o cualquier otra persona tales como: pureza, sabor, color, madurez, etc., entonces se dice que el producto tiene calidad. Estos requisitos pueden ser medibles, lo cual permite pensar en sistemas capaces de verificar la calidad. Aunque cada uno de nosotros es capaz de identificar los defectos que pueda tener cierto producto y decidir si comprarlo o no, para el caso de esta tesis se necesitó de la información que un experto humano productor de manzanas tiene sobre el producto. La información que proporciona el experto permite entender el lenguaje y los conceptos que él manipula.

Capítulo 5 Caso de estudio

62

Pero ¿cuáles son algunas de las características necesarias para comprobar la calidad en frutas y hortalizas? Uno de los documentos expertos propone las siguientes [1]: Por apariencia:

- Tamaño: referido a peso, largo, ancho, circunferencia, diámetro, número de unidades en un determinado empaque, etc.

- Forma: determina la aceptación en el mercado y facilita el empacado en forma regular.

- Color: impresión visual que se forma el cliente. - Brillo: causado por la acumulación de ceras sobre la superficie del producto. - Defectos superficiales: heridas, quemaduras, enfermedades, cicatrices, etc., en

muchos mercados son inaceptables.

Por textura (táctiles):

- Firmeza: Indica al consumidor la manera en que el producto ha sido manejado. - Suculencia: jugosidad del producto, característica para cada especie o variedad.

Por sabor (gusto y olfato):

- Dulzura: frutos poco dulces serán considerados de mala calidad; otros con demasiados azúcares pueden indicar baja calidad.

- Acidez: el sabor de una fruta está dado por el balance entre sus azúcares y sus ácidos orgánicos.

- Astringencia: es poco deseable, aunque en algunos es parte del sabor normal de la fruta.

- Amargura: es una característica indeseable. - Aroma (olor): el olor de cada producto fresco debe ser característico y depende de

compuestos volátiles. Por seguridad:

- Algunos cultivos presentan compuestos naturales que pueden ser peligrosos para el consumidor (variedades de yuca con contenidos de cianuro y papas con alcaloides), por lo que se deben considerar al definir la calidad de estos productos.

- El uso de agroquímicos autorizados debe ser del conocimiento del productor para utilizarlos reguladamente.

Otro documento experto [Symons-2002] clasifica los atributos de calidad que definen a los productos alimenticios de la siguiente manera: - Externos

Aspecto (vista) Sensación (tacto) Defectos


63

- Internos

Olor Sabor Textura (consistencia)

- Ocultos

Salubridad Valor nutritivo Seguridad

A continuación se explican estos 3 grupos de atributos:

Cuando se va a un comercio a escoger una fruta, lo primero que se hace es observarla detenidamente, verificando que no tenga defectos, así los atributos que son observados en primera cuenta, son aquellos conocidos como externos. El consumidor siempre estará guiado por estos atributos, ya que siempre se decide si comprar o no cierta fruta por el aspecto que ésta tenga o por la sensación que ésta nos de al tocarla. Los sentidos partícipes en esta verificación son principalmente la vista y el tacto. Si se tiene la oportunidad de que el producto en cuestión pueda ser cortado y probado, entonces se podrán apreciar otros atributos que decidirán finalmente nuestra apreciación de la calidad. Esta verificación está relacionada con el sabor, el aroma y la sensación que ésta produce. A estos atributos se les conoce como internos. Los atributos que no pueden ser ni observados, ni tocados, ni probados, son aquellos relacionados con aspectos de salubridad, seguridad y valor nutricional. A estos atributos se les conoce como ocultos. Para poder realizar la medición en la calidad de los productos existen métodos que se encargan de valorarla. Estos métodos deberán estar sujetos a la forma en la cual los consumidores evalúan la calidad, es decir, tendrán que estar relacionados con las funciones que realizan los sentidos involucrados en la aceptación o rechazo al producto en cuestión. A continuación se presenta una lista detallada de los atributos de calidad [Symons-2002] antes mencionados. 5.1.1 Atributos externos - En este aspecto incluyen factores tales como el tamaño, la forma, el brillo, el color y ausencia de defectos.

o El tamaño y la forma son mediciones utilizadas como normas de clasificación o para diferenciar entre productos. La evaluación del tamaño y la forma es


64

frecuentemente un proceso subjetivo, aunque para muchos productos se han desarrollado guías visuales.

o El color es un indicador primario de la madurez y es el resultado del tipo y la

cantidad de pigmentos presentes en el producto. Los cambios en el color están a menudo relacionados con la “frescura” o el deterioro del producto. El color puede medirse a través de muchos métodos visuales o mecánicos (por ejemplo, colorímetros y espectrofotómetros).

- La firmeza, o la sensación que provoca el producto al tacto, está relacionada con el ablandamiento del producto. La firmeza es resultado de la estructura de la pared celular y de la presión interna (turgencia) de las células. La pérdida de firmeza puede estar provocada por golpes, maduración u otros mecanismos de descomposición.

o La firmeza se mide normalmente a través de medios mecánicos (por ejemplo: análisis de textura).

- Los defectos pueden deberse a la producción, la manipulación, el medio ambiente, las enfermedades y otros factores.

o Los defectos normalmente se miden visualmente, aunque se están desarrollando algunos métodos mecánicos (por ejemplo, visión a través de ultrasonidos y máquinas).

5.1.2 Atributos internos - El olor o el aroma es la suma de los compuestos percibidos por la nariz. Es muy difícil de determinar objetivamente, ya que se trata de una combinación de rasgos cualitativos (predominantes) y cuantitativos en un producto. Las frutas y hortalizas son ricas en compuestos aromáticos, muchos de los cuales aun están por ser identificados.

o Pueden realizarse mediciones limitadas del olor a través de espectrómetros de masa (cromatógrafos de gases o mecanismos similares).

- El sabor es la percepción de los compuestos químicos en la lengua y otras terminaciones nerviosas de la boca. Los sabores básicos son dulce, ácido, amargo y astringente.

o La dulzura está directamente relacionada con los azúcares presentes en el alimento y con la proporción de azúcar frente al ácido. La acidez es el resultado de los ácidos orgánicos presentes. Compuestos como los existentes en los cítricos o el café normalmente producen sabores amargos, mientras que la astringencia es resultado de taninos como los compuestos fenólicos que se encuentran en las uvas. Existen numerosos métodos para cuantificar los compuestos del sabor, entre los que se encuentran métodos espectrofotométricos y gravimétricos, cromatografía líquida y gaseosa.


65

- La consistencia es “el conjunto formado por aquellas propiedades que surgen de los elementos estructurales de un producto y la forma en que este conjunto se refleja en los sentidos fisiológicos” [Szczesniak-1977]. La mayoría de las características de la textura, a excepción de la firmeza, se evalúan mediante sensaciones en la boca, es decir, la impresión que produce en la lengua, el paladar y los dientes.

o En los productos, las características más comunes de la textura incluyen, el hecho de que una fruta sea tierna, consistente, crujiente, masticable y fibrosa. La consistencia se determina normalmente midiendo la fuerza aplicada al alimento en el consumo de la fruta.

5.1.3 Atributos ocultos - La salubridad está habitualmente relacionada con la “frescura”. Los defectos de salubridad pueden derivarse del propio alimento o de factores externos como el medio ambiente (temperatura, humedad, etc.) o la manipulación (cortes, golpes).

o La salubridad es un atributo relativamente difícil de medir objetivamente, pero con frecuencia se toma en cuenta en el momento de clasificar y establecer el precio del producto. Este atributo también implica un componente “sanitario” (el grado de higiene y/o limpieza) del producto y la presencia de materiales extraños. Entre las técnicas utilizadas para medir estos atributos se encuentran tecnologías microscópicas, microbiológicas y de rayos X.

- El valor nutritivo está relacionado con la presencia y los niveles de los componentes que sustentan la vida.

o Las frutas y hortalizas son apreciadas como fuentes de vitaminas y minerales esenciales, así como de fibra. En los últimos años también han sido reconocidas como fuentes de antioxidantes y otras sustancias fitoquímicas que están siendo estudiadas por su papel en la prevención o el control de ciertas enfermedades humanas. La calidad y cantidad de estos componentes nutricionales son muy importantes y son esenciales para el bienestar del consumidor. Los análisis por vía húmeda, distintos métodos cromatográficos y otras pruebas químicas y físicas miden el valor nutricional.

- La seguridad se define como la garantía de que un alimento no provocará perjuicios al consumidor cuando se prepare y/o consuma de acuerdo con su uso previsto [FAO/OMS- 1997].

o El examen microbiológico es el principal método utilizado para identificar el tipo y

la cantidad de microorganismos patogénicos.

o Pueden evaluarse las prácticas de producción y manipulación para garantizar que se adoptaron las medidas necesarias para minimizar el riesgo de contaminación microbiana.


66

Para el desarrollo de esta tesis, los atributos que fueron utilizados para la verificación de la calidad en las manzanas son los de tipo “externo”. Sin embargo, de este conjunto de atributos (ya descritos anteriormente) nos interesamos por aquellos que pueden ser sujetos a medición o verificación visual. Una vez que hemos conocido la definición de la calidad de las frutas y de los atributos utilizados para su verificación, a continuación se presentan las normas de calidad correspondientes al caso de estudio: las manzanas. 5.2 Normas de calidad para manzanas A continuación se presentan las normas de calidad [2] por medio de las cuales son verificadas las manzanas destinadas al consumo interno de Estados Unidos. Para ello, se describirán las características que deben tener y su clasificación de calidad. 5.2.1 Características

En todas las categorías las manzanas deben presentarse:

o Enteras. o Sanas, se excluyen en todo caso los frutos afectados de podredumbre o

alteraciones tales que los hagan impropios para el consumo. o Limpias, prácticamente exentas de materias extrañas visibles. o Exentas de humedad exterior anormal. o Exentas de olor y/o sabores extraños. o Los frutos deben haber sido recogidos cuidadosamente y presentar

un desarrollo suficiente y un estado de madurez tales que les permita: - Soportar la manipulación y el transporte. - Responder en el lugar de destino a las exigencias comerciales.

5.2.2 Clasificación

-Categoría "Extra": los frutos clasificados en esta categoría serán de calidad superior. Presentarán la forma, desarrollo y coloración característicos de la variedad. Los frutos presentarán el tallo intacto y estarán exentos de defectos, a excepción de muy ligeras alteraciones de la epidermis, siempre que no perjudiquen al aspecto general, a la calidad, ni a su presentación en el envase. -Categoría "I": los frutos clasificados en esta categoría serán de calidad superior. Presentarán las características típicas de la variedad. No obstante, puede admitirse:

o Una ligera deformación. o Un ligero defecto de desarrollo. o Un ligero defecto de coloración. o Que el tallo pueda estar ligeramente dañado.


67

o La pulpa debe estar exenta de todo daño; sin embargo, se admiten para cada fruto defectos de epidermis, siempre que no afecten al aspecto general, ni a la conservación dentro de los siguientes límites:

- Los defectos de forma alargada no excederán en total de 2 cm. de longitud. - Para los otros defectos, la superficie total no debe exceder de 1cm2 a

excepción del moteado, que no debe presentar una superficie superior a 1/4 de cm2.

-Categoría "II": en esta categoría se incluyen los frutos que no pueden clasificarse en las categorías superiores, pero responden a las categorías mínimas de calidad.

o Se admiten defectos de forma, desarrollo y coloración a condición de que los

frutos conserven sus características. El tallo puede faltar, siempre que no haya deterioro de la epidermis.

o La pulpa no debe presentar defectos esenciales. Se admiten para cada fruto defectos de epidermis dentro de los siguientes límites:

- Defectos de forma alargada: no excederán en total de 4 cm. de longitud. - Para los otros defectos, la superficie total no debe exceder de 2.5 cm2 a

excepción del moteado, que no debe presentar una superficie superior a 1 cm2.

-Categoría "III": esta categoría comprende los frutos que no pueden ser clasificados en una categoría superior pero que responden a las características previstas para la categoría "II", con excepción de los defectos de la epidermis que pueden ser más importantes, siempre que no excedan de:

- 6 cm. de longitud en total para los defectos de forma alargada. - 5 cm2 de superficie en total para los otros defectos, a excepción del

moteado, que no debe presentar una superficie total superior a 2.5 cm2.

5.3 Especies de manzanas A continuación se presentan las especies de manzanas que fueron estudiadas en el desarrollo de esta tesis. Para cada una de ellas, se presentan sus características de la cosecha (conjunto de productos de la recolección), así como la calidad esperada [2]. 5.3.1 Manzana "Golden Delicious"

-Cosecha: o Cambio del color verde oscuro a verde claro o verde

amarillento (del 20 al 40% de la pulpa libre de almidón). o Generalmente entre 135 a 150 días después de floración.

(ver figura 4.1).


68

-Calidad:

o Firmeza, crujiente, ausencia de harinosidad. o Sabor, incluye sólidos solubles, acidez titulable y

compuestos aromáticos volátiles.

o Ausencia de defectos como golpes, pudrición, partiduras de la cavidad calicinar o peduncular, picado amargo (bitter pit), escaldado, pardeamiento interno, arrugamiento.

Figura 5.1: Manzana Golden Delicious. 5.3.2 Manzana "Red Delicious"

-Cosecha: o Corazón sin almidón. (ver figura 5.2).

-Calidad:

o Firmeza, crujiente, ausencia de harinosidad. o Sabor, incluye sólidos solubles, acidez titulable y

compuestos aromáticos volátiles. o Ausencia de defectos como golpes, pudrición, partiduras

de la cavidad calicinar o peduncular, picado amargo (bitter pit), escaldado, pardeamiento interno, arrugamiento y corazón acuoso.

o Color de la piel rojo intenso y uniforme.

Figura 5.2: Manzana Red Delicious.


69

5.3.3 Manzana "Gala"

-Cosecha: o El cambio de color de fondo de verde a verde claro o

blanco puede ser el indicador más recomendable para los cosechadores.

o El comienzo de la degradación del almidón puede también indicar el tiempo de cosecha (ver figura 5.3).

-Calidad: o Firmeza, crujiente, ausencia de harinosidad. o Sabor, incluye sólidos solubles, acidez y compuestos

aromáticos volátiles. o Ausencia de defectos como golpes, pudrición, partiduras

de la cavidad calicinar o peduncular, picado amargo (bitter pit), daño por insectos, etc.

o Porcentaje de coloración de la manzana (calidad visual solamente).

Figura 5.3: Manzana Gala.

5.3.4 Manzana "Fuji"

-Cosecha: o El cambio de color de fondo de verde a verde claro o blanco

puede ser un indicador útil para los cosechadores. o La fruta debe ser cosechada antes de la completa degradación

del almidón. o Con base en una limitada investigación, la cosecha de la fruta

debe efectuarse alrededor de los 180 y 190 días después de la floración para reducir la incidencia de desórdenes fisiológicos (partidura de la piel y pardeamiento interno (skin cracking-internal browning)). (ver figura 5.4).

-Calidad:

o Firmeza, crujiente y ausencia de harinosidad. o Sabor, incluye sólidos solubles, acidez titulable y compuestos

aromáticos volátiles.


70

o Ausencia de defectos como golpes, pudrición, partiduras de la cavidad calicinar o peduncular y de la piel (cheking), picado amargo (bitter pit), daño por insectos, etc.

o Porcentaje de coloración de la manzana.

Figura 5.4: Manzana Fuji.

5.3.5 Manzana "Granny Smith"

-Cosecha: o Cuando el promedio del índice del almidón de una

muestra de 30 frutos es igual o mayor que 2.5 en una escala de 0 a 6 (California Granny Smith Apple Starch Scale), basado en el porcentaje del área del corazón y pulpa teñidos de azul oscuro, cuando los frutos se han sumergido en una solución yodo-yodurada de potasio. (ver figura 5.5).

-Calidad:

o Sabor, incluye sólidos solubles (12% o mayor), acidez titulable (0.75% o menor) y compuestos aromáticos volátiles.

o Para mejorar la calidad de consumo, los frutos cosechados temprano en la temporada pueden ser acondicionados con un tratamiento con etileno de 100 ppm por 24 horas a 20°C para la venta inmediata.

o Ausencia de defectos como golpes, pudrición, partiduras de la cavidad calicinar o peduncular, bitter pit, daño por insectos y corazón acuoso.

o Color verde profundo y ausencia de colores atípicos y/o quemado de sol (manchas amarillas o pardas).

Figura 5.5: Manzana Granny Smith.


71

5.4 Discusión Atributos externos considerados a partir del caso de estudio “calidad en las manzanas” tablas 5.1 y 5.2. Estos atributos fueron seleccionados de manera tal, que fueran compatibles con los atributos que pudieran ser obtenidos mediante un sistema de visión artificial. [Moctezuma-2004].

Tabla 5.1: Atributos utilizados en este trabajo. Atributos Valor Unidad

defectos_alarg_partiduras 0 – 6 cm defectos_moteado 0 – 2.5 cm2 defectos_varios 0 – 5 cm2 Tallo V/F V=tiene | F=no tiene Color_rojo 0-255 pixel Color_verde 0-255 pixel Color_azul 0-255 pixel

Tabla 5.2: Rango de valores para el RGB de cada manzana según su categoría.

Categoría Color_rojo(R) Color_verde(G) Color_azul(B) Categoría_extra 105 184 90 158 46 65 Categoría_I 92 145 100 149 40 59 Categoría_II 95 133 110 138 44 61 Categoría_III 99 145 98 139 32 62

La tabla 5.2 muestra los rangos en pixeles obtenidos en cada una de las imágenes de las manzanas según su categoría. Como puede observar existe un traslape entre los rangos de color, sin embargo aún así, los datos fueron utilizados tal cual en todas y cada una de las pruebas. Las reglas obtenidas a partir de la información son las que se muestran a continuación.

1. SI tiene el color correspondiente a la tabla (ver tabla 5.3 categoría extra) y tiene presencia del tallo y no tiene defectos alargados y no tiene defectos varios y no tiene defectos de moteado ENTONCES categoría extra.

2. SI tiene el color correspondiente a la tabla (ver tabla 5.3 categoría I) y tiene

presencia del tallo y tiene defectos alargados que no exceden de 2cm y tiene defectos varios que no exceden de 1cm2 y tiene defectos de moteado que no exceden de ¼ cm2 ENTONCES categoría I.

3. SI tiene el color correspondiente a la tabla (ver tabla 5.3 categoría II) y no tiene

presencia del tallo y tiene defectos alargados que no exceden de 4cm y tiene defectos varios que no exceden de 2.5 cm2 y tiene defectos de moteado que no exceden de 1 cm2 ENTONCES categoría II.


72

4. SI tiene el color correspondiente a la tabla (ver tabla 5.3 categoría III) y no tiene presencia del tallo y tiene defectos alargados que no exceden de 6cm y tiene defectos varios que no exceden de 5 cm2 y tiene defectos de moteado que no exceden de 2.5 cm2 ENTONCES categoría III.

Con la información anterior se llevan a cabo las pruebas pertinentes a este caso de estudio.

CAPÍTULO 6 PRUEBAS Y RESULTADOS En este capítulo se explica el funcionamiento de CompSimb con 2 casos de estudio. El primer caso consiste en una prueba académica denominada “Monks problem” [Thrun-1992] el cual fue seleccionado debido a que contiene una parte simbólica y otra numérica. El segundo caso de estudio se eligió como un caso de aplicación en el cual se introducen reglas aplicadas para determinar la calidad en las manzanas (ver capítulo 5). A continuación se describen a detalle los casos así como la redacción de cada una de las reglas introducidas al sistema y finalmente se hace un análisis de los resultados obtenidos. 6.1 Caso de estudio “Monks problem” Este caso de estudio fue utilizado con el propósito de validar el funcionamiento del sistema. Para ello, las pruebas fueron realizadas sobre tres enfoques: numérico, conexionista e híbrido. A continuación se muestran los atributos y las reglas que definen este problema [Thrun-1992] la información utilizada fue obtenida del repositorio de machine learning. 6.1.1 Atributos Número de atributos: 8 (incluyendo la clase a la cual pertenece el atributo) Información de los atributos:

1. clase: 0, 1 2. a1: 1, 2, 3 3. a2: 1, 2, 3 4. a3: 1, 2 5. a4: 1, 2, 3 6. a5: 1, 2, 3, 4 7. a6: 1, 2 8. id: (un símbolo único para cada instancia)

Base total = 432 ejemplos (Base de prueba)

100% Base de aprendizaje = 124 ejemplos el cual se divide a su vez en, 75% Base de aprendizaje = 93 ejemplos, 50% Base de aprendizaje = 62 ejemplos, 25% Base de aprendizaje = 31 ejemplos.

Capítulo 6 Pruebas y Resultados

74

Los ejemplos de las bases de aprendizaje del 75, 50 y 25% fueron seleccionados aleatoriamente. Para el caso de la generalización se toman los 432 ejemplos del archivo de base de prueba más el porcentaje seleccionado de la base de aprendizaje. La base de aprendizaje fue dividida con el propósito de observar qué sucede cuando esta base es reducida y complementada con el conocimiento simbólico. 6.1.2 Regla de producción del caso de estudio “Monks”

MONK-1: (a1 = a2) o (a5 = 1) La interpretación de esta regla de producción es la siguiente: Se trata de un monk si el valor del atributo a1 es igual al valor del atributo a2 ó el atributo a5 tiene un valor igual a 1. Para efectos de realizar las pruebas R1 representa al antecedente a1 = a2 y R2 representa al antecedente a5 = 1. Cuando se habla de R1 y R2 se refiere a los antecedentes (a1 = a2) y (a5 = 1) respectivamente. Las reglas fueron divididas en R1 y R2 con el propósito de observar qué sucede cuando no existe alguna de las dos reglas y esta es complementada con el conocimiento numérico. 6.1.3 Implementación del caso de estudio “Monks problem” en el sistema CompSimb La tabla 6.1 muestra el nombre de la variable que representa a cada uno de los atributos, así como el tipo y el valor que le corresponde.

Tabla 6.1: Discretización de los atributos para el caso de Monk’s problem. Atributos Tipo Valor a1 NOMINAL 1,2,3 a2 NOMINAL 1,2,3 a3 BINARIO 1,2 a4 NOMINAL 1,2,3 a5 NOMINAL 1,2,3,4 a6 BINARIO 1,2

A continuación se presentan los tres tipos de pruebas realizadas. Una para cada uno de los enfoques: conexionista, simbólico e híbrido. a) Enfoque conexionista. En esta prueba, sólo se tiene la base de ejemplos (conocimiento numérico). Con ello se quiere observar los resultados que se obtienen únicamente con el conocimiento numérico. Para realizar las pruebas utilizando este enfoque, se le suministra al sistema Neusim los siguientes archivos:

• Archivo de la base de prueba *.tst • Archivo de la base de aprendizaje *.lrn • Archivo de configuración *.cfg


75

La base de conocimientos numérica (archivo de aprendizaje) se divide en 100, 75, 50 y 25%. Por lo tanto, las pruebas realizadas para este enfoque se llevaron a cabo tomando en cuenta lo siguiente:

a) Con el 100% de la base de aprendizaje, es decir, 128 ejemplos. b) Con el 75% de la base de aprendizaje, es decir, 93 ejemplos. c) Con el 50% de la base de aprendizaje, es decir, 62 ejemplos. d) Con el 25% de la base de aprendizaje, es decir, 31 ejemplos.

El resultado obtenido en el enfoque conexionista se puede observar en la tabla 6.2 b) Enfoque simbólico. En esta prueba, solo se tiene la red neuronal inicial generada a partir de la compilación de las reglas (conocimiento simbólico) a una RNA. Con lo anterior, se quiere observar los resultados que se obtienen únicamente con el conocimiento simbólico. Para llevar a cabo lo anterior, la regla de producción fue dividida como sigue:

1) R1 y R2 consiste en los antecedentes a1 = a2 ó a5 = 1, por lo tanto los atributos utilizados en las reglas son a1, a2 y a5, siendo a3, a4 y a6 considerados como atributos adicionados por el usuario. Donde estos atributos se adicionan debido a que no se encuentran en las reglas pero sabemos que sí existen en la base de ejemplos, por lo tanto deben de ser considerados para efectos de compatibilidad.

2) R1 consiste en el antecedente a1 = a2, por lo tanto los atributos utilizados en las

reglas son a1 y a2, siendo a3, a4, a5 y a6 considerados como atributos adicionados por el usuario.

3) R2 consiste en el antecedente a5 = 1, por lo tanto el atributo utilizado en la regla

es a5, siendo a1, a2, a3, a4 y a6 considerados como atributos adicionados por el usuario.

El resultado obtenido en el enfoque simbólico se puede observar en la tabla 6.2. c) Enfoque híbrido. En esta prueba, una vez que se tiene nuestra red neuronal artificial procedemos a realizar el refinamiento de nuestros conocimientos simbólicos y conexionistas. Para ello se realizan tres subpruebas, en la primera se utilizan el total de las reglas, en la segunda y la tercera se utiliza solo la mitad de ellas. La razón de combinar un número determinado de antecedentes y un porcentaje determinado de ejemplos, es de observar lo que sucede cuando carecemos de conocimiento ya sea del conocimiento simbólico o del conocimiento numérico, o en ambas, y la medida en la cual se están complementando.


76

1) Subprueba uno. En esta subprueba se observan los resultados que se obtienen al integrar el conocimiento numérico y simbólico del problema tomando en cuenta el total de las reglas (R1y R2). El refinamiento fue obtenido a partir de la compilación de:

1) 100% de las reglas (R1 y R2) y 100% de la base de ejemplos. 2) 100% de las reglas (R1 y R2) y 75% de la base de ejemplos. 3) 100% de las reglas (R1 y R2) y 50% de la base de ejemplos. 4) 100% de las reglas (R1 y R2) y 25% de la base de ejemplos.

2) Subprueba dos. En esta subprueba se observan los resultados que se obtienen al integrar el conocimiento numérico y simbólico del problema tomando en cuenta la mitad de las reglas (R1). El refinamiento fue obtenido a partir de la compilación de:

1) 50% de las reglas (R1) y 100% de la base de ejemplos. 2) 50% de las reglas (R1) y 75% de la base de ejemplos. 3) 50% de las reglas (R1) y 50% de la base de ejemplos. 4) 50% de las reglas (R1) y 25% de la base de ejemplos.

3) Subprueba tres. En esta subprueba se observan los resultados que se obtienen al integrar

el conocimiento numérico y simbólico del problema tomando en cuenta la mitad de las reglas (R2). El refinamiento fue obtenido a partir de la compilación de:

1) 50% de las reglas (R2) y 100% de la base de ejemplos. 2) 50% de las reglas (R2) y 75% de la base de ejemplos. 3) 50% de las reglas (R2) y 50% de la base de ejemplos. 4) 50% de las reglas (R2) y 25% de la base de ejemplos.

Los resultados obtenidos en el enfoque híbrido se puede observar en la tabla 6.2


77

6.1.4 Resultados obtenidos Los resultados obtenidos se muestran en la tabla 6.2.

Tabla 6.2: Resultados obtenidos en el caso de estudio Monk’s problem.

Caso (enfoque)

Reglas compiladas

Ejemplos utilizados

%

Conocimiento %

Generalización %

Unidades Ocultadas Agregadas

Épocas de aprendizaje

- 100 100 99.07 2 484 - 75 100 87.03 7 1614 - 50 100 59.95 5 983

a) Conexionista

- 25 55.09 55.09 2 320 R1 y R2 - - 100 0 0 R1 - - 93.05 0 0

b) Simbólico

R2 - - 81.94 0 0 1) R1 y R2 100 100 98.61 1 84 R1 y R2 75 100 98.61 1 95 R1 y R2 50 100 98.61 1 92 R1 y R2 25 100 95.13 1 82 2) R1 100 100 99.53 1 82 R1 75 100 99.30 1 78 R1 50 100 94.21 1 69 R1 25 100 77.03 1 67 3) R2 100 100 95.83 3 628 R2 75 100 73.14 6 1226 R2 50 100 63.42 4 872

c) Híbrido

R2 25 100 51.85 1 58

Monks problem

0

20

40

60

80

100

120

- - - - R1 yR2

R1 R2 1)R1 yR2

R1y R2

R1y R2

R1y R2

2)R1

R1 R1 R1 3)R2

R2 R2 R2

a) Conexionista b) Simbólico c) Híbrido

Reglas

Por

cent

aje

Ejemplos utilizados % Generalización %

Enfoque

Figura 6.1: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio Monk’s problem.


78

CONEXIONISTA VS HÍBRIDO

-50

-40

-30

-20

-10

0

10

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

100EJR1R2100

100EJR1R275

100EJR1R250

100EJR1R225

100EJR1_100

100EJR1_75

100EJR1_50

100EJR1_25

100EJR2_100

100EJR2_75

100EJR2_50

100EJR2_25


-40

-30

-20

-10

0

10

20

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

100EJR1R2100

100EJR1R275

100EJR1R250

100EJR1R225

100EJR1_100

100EJR1_75

100EJR1_50

100EJR1_25

100EJR2_100

100EJR2_75

100EJR2_50

100EJR2_25

Figura 6.2: Porcentaje de generalización entre el enfoque conexionista con 100 ejemplos y el enfoque híbrido de Monk’s problem.



79


-20

-10

0

10

20

30

40

50

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

100EJR1R2100

100EJR1R275

100EJR1R250

100EJR1R225

100EJR1_100

100EJR1_75

100EJR1_50

100EJR1_25

100EJR2_100

100EJR2_75

100EJR2_50

100EJR2_25


-10

0

10

20

30

40

50

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

100EJR1R2100

100EJR1R275

100EJR1R250

100EJR1R225

100EJR1_100

100EJR1_75

100EJR1_50

100EJR1_25

100EJR2_100

100EJR2_75

100EJR2_50

100EJR2_25




80

SIMBÓLICO VS HÍBRIDO

-60

-50

-40

-30

-20

-10

01

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

R1R2_R1R2100

R1R2_R1R275

R1R2_R1R250

R1R2_R1R225

R1R2_R1_100

R1R2_R1_75

R1R2_R1_50

R1R2_R1_25

R1R2_R2_100

R1R2_R2_75

R1R2_R2_50

R1R2_R2_25


-50

-40

-30

-20

-10

0

10

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

R1_R1R2_100

R1_R1R2_75

R1_R1R2_50

R1_R1R2_25

R1_R1_100

R1_R1_75

R1_R1_50

R1_R1_25

R1_R2_100

R1_R2_75

R1_R2_50

R1_R2_25

Figura 6.6: Porcentaje de generalización entre el enfoque simbólico con el total de reglas y el enfoque híbrido de Monk’s problem.

Figura 6.7: Porcentaje de generalización entre el enfoque simbólico con la regla R1 y el enfoque híbrido

de Monk’s problem.


81


-40

-30

-20

-10

0

10

20

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

R2_R1R2_100

R2_R1R2_75

R2_R1R2_50

R2_R1R2_25

R2_R1_100

R2_R1_75

R2_R1_50

R2_R1_25

R2_R2_100

R2_R2_75

R2_R2_50

R2_R2_25

Figura 6.8: Porcentaje de generalización entre el enfoque simbólico con la regla R2 y el enfoque híbrido

de Monk’s problem. 6.1.5 Análisis de resultados De los resultados antes obtenidos (ver tabla 6.2) se puede observar que efectivamente en algunos casos, en los cuales se integra el conocimiento numérico y el conocimiento simbólico, el porcentaje en la generalización es más alto, que aquellos casos donde tanto el conocimiento numérico como el simbólico se prueban separadamente. Comparando el inciso a) y c-2) se puede observar que cuando se integra el 50% del conocimiento simbólico (R1) y el 25% del conocimiento numérico, se obtiene un porcentaje del 77.03% de la generalización, siendo éste mayor que el obtenido en el inciso a) donde se tiene solamente el conocimiento numérico de tan solo el 25% de los ejemplos obteniendo un 55.09% en la generalización. Por otro lado si se compara el inciso b) donde sólo se tiene el conocimiento simbólico con una sola regla (R1) y el inciso c-2) donde se tiene la integración de los dos tipos de conocimientos, éste último es superior, ya que para el inciso b) el porcentaje de generalización es de 93.05% mientras que para el inciso c-2) integrado por R1 y el 75% de los ejemplos se obtuvo un 99.30%. En cuanto al número de épocas de aprendizaje el enfoque híbrido tiene muchos mejores resultados con un 35.01% en promedio. Del caso en el cual el enfoque simbólico fue mayor que el enfoque híbrido y simbólico, se puede concluir que el conocimiento numérico es el puede ser mejorado siendo complementado con el conocimiento simbólico en un enfoque híbrido.


82

6.2 Caso de estudio “calidad en las manzanas” En las manzanas, dependiendo del valor de sus atributos externos, le corresponde una cierta categoría. Las manzanas por su calidad se dividen en categoría extra, categoría I, categoría II y categoría III. A continuación se muestran los atributos y las reglas de producción que se formularon para cada una de estas categorías. 6.2.1 Atributos Los atributos o características que fueron identificados durante el estudio de este problema y que fueron utilizados para la formulación de las reglas simbólicas son los atributos externos siguientes:

Defectos alargados Defectos de moteado Defectos varios Tallo Color correspondiente

El atributo “color correspondiente” es dividido en sus tres componentes (RGB, rojo-verde-azul). Siendo así siete los atributos utilizados en total: defectos alargados, defectos de moteado, defectos varios, tallo, color_rojo, color_verde y color_azul. 6.2.2 Reglas de producción del caso de estudio “calidad en las manzanas” A continuación se presentan las reglas de producción las cuales contienen los criterios que se deben de cumplir para que una manzana pertenezca a cualquiera de las cuatro categorías.

1. SI tiene el color correspondiente a la tabla (ver tabla 6.3) y tiene presencia del tallo y no tiene defectos alargados y no tiene defectos varios y no tiene defectos de moteado ENTONCES categoría extra.

2. SI tiene el color correspondiente a la tabla (ver tabla 6.3) y tiene presencia del tallo

y tiene defectos alargados que no exceden de 2cm y tiene defectos varios que no exceden de 1 cm2 y tiene defectos de moteado que no exceden de ¼ cm2 ENTONCES categoría I.

3. SI tiene el color correspondiente a la tabla (ver tabla 6.3) y no tiene presencia del

tallo y tiene defectos alargados que no exceden de 4cm y tiene defectos varios que no exceden de 2.5 cm2 y tiene defectos de moteado que no exceden de 1 cm2 ENTONCES categoría II.

4. SI tiene el color correspondiente a la tabla (ver tabla 6.3) y no tiene presencia del

tallo y tiene defectos alargados que no exceden de 6cm y tiene defectos varios que no exceden de 5 cm2 y tiene defectos de moteado que no exceden de 2.5 cm2 ENTONCES categoría III.


83

Estas reglas no fueron validadas aún por el experto humano, por lo que se recomienda para trabajos futuros.

Tabla 6.3: Valores de RGB para el caso de la manzana Golden [Vergara-2003]. Categoría R G B Categoría_extra 105 184 90 158 46 65 Categoría_I 92 145 100 149 40 59 Categoría_II 95 133 110 138 44 61 Categoría_III 99 145 98 139 32 62

6.2.3 Implementación del caso de estudio calidad en las manzanas en el sistema CompSimb La tabla 6.4 muestra el nombre de variable que representa a cada uno de los atributos, así como el tipo y el valor que les corresponde.

Tabla 6.4: Discretización de los atributos para el caso de calidad en las manzanas. Atributos Tipo Valor defectos_alarg_partiduras RANGO 0 – 6 defectos_moteado RANGO 0 – 2.5 defectos_varios RANGO 0 – 5 Tallo BINARIO V/F Color_rojo RANGO 0-255 Color_verde RANGO 0-255 Color_azul RANGO 0-255

Se realizaron tres tipos de pruebas. Una para cada uno de los enfoques: conexionista, simbólico e híbrido. A continuación se presenta una breve explicación de las pruebas para cada uno de estos enfoques. a) Enfoque conexionista. El propósito de utilizar este enfoque es el de saber los resultados que se pueden obtener utilizando solamente un conjunto de ejemplos (conocimiento numérico). Para realizar las pruebas, se le suministra al sistema Neusim los siguientes archivos:

• Archivo de la base de prueba *.tst • Archivo de la base de aprendizaje *.lrn • Archivo de configuración *.cfg

La base de prueba consta de un total de 148 ejemplos, de una base de imágenes de manzanas obtenidas por el grupo de visión artificial, cenidet [Moctezuma-2004]. Se realizaron tres tipos de pruebas:


84

a) Con el 100% de la base de aprendizaje, es decir, 148 ejemplos b) Con el 75% de la base de aprendizaje, es decir, 111 ejemplos, c) Con el 50% de la base de aprendizaje, es decir, 74 ejemplos.

La reducción de ejemplos en la base de aprendizaje es para observar lo que sucede cuando el conocimiento numérico no está completo.

Para cada prueba se obtuvo como salida la topología, los pesos de la red y el archivo de resumen, el cual contiene información de los resultados obtenidos del entrenamiento y del aprendizaje. Los resultados se pueden observar en las tablas 6.5 a la 6.9. b) Enfoque simbólico. En esta prueba se compilan las reglas (conocimiento simbólico) que determinan que dado que una manzana Golden pueda pertenecer o no a cierta categoría. Una vez que cada una de las reglas fueron compiladas (mapeadas) a una RNA inicial, se obtuvieron los archivos de topología y de pesos de la RNA. Estos archivos fueron utilizados en el sistema Neusim para realizar el reconocimiento. Para llevar a cabo lo anterior, se realizaron tres tipos de pruebas. En la primera se consideraron los siete atributos involucrados en la regla (R7). En una segunda prueba los atributos considerados en la regla fueron reducidos a cinco de ellos (R5) considerando los atributos restantes como parte de los atributos que no se encuentran en las reglas, pero que se encuentran en la base de conocimiento numérica, es decir, los adicionados por el usuario. Y en la tercer prueba los atributos considerados en la reglas fueron cuatro (R4) siendo el resto de los atributos colocados como parte de los atributos adicionados por el usuario. A continuación se muestran los atributos que fueron utilizados en cada una de éstas pruebas. Prueba 1. Los atributos involucrados en la regla son los siguientes (R7):

defectos_alarg_partiduras defectos_moteado defectos_varios Tallo Color_rojo Color_verde Color_azul

Prueba 2. Los atributos involucrados en la regla son los siguientes (R5):

Color_rojo Color_verde Color_azul Tallo defectos_alarg_partiduras


85

Prueba 3. Los atributos involucrados en la regla son los siguientes (R4):

defectos_alarg_partiduras defectos_moteado defectos_varios Tallo

Los resultados del enfoque simbólico se muestran en las tablas 6.5 a la 6.9. c) Enfoque híbrido. En éstas pruebas se demuestra que en el enfoque híbrido, se obtiene una complementariedad de conocimientos al integrar el conocimiento simbólico (reglas) junto con el conocimiento numérico (base de ejemplos). Para ello, los conocimientos simbólico y numérico se combinaron en nueve pruebas.

R7 (7 atributos involucrados en la regla) y 100% de la base de ejemplos R7 (7 atributos involucrados en la regla) y 75% de la base de ejemplos R7 (7 atributos involucrados en la regla) y 50% de la base de ejemplos R5 (5 atributos involucrados en la regla) y 100% de la base de ejemplos R5 (5 atributos involucrados en la regla) y 75% de la base de ejemplos R5 (5 atributos involucrados en la regla) y 50% de la base de ejemplos R4 (4 atributos involucrados en la regla) y 100% de la base de ejemplos R4 (4 atributos involucrados en la regla) y 75% de la base de ejemplos R4 (4 atributos involucrados en la regla) y 50% de la base de ejemplos

Los resultados del enfoque híbrido se muestran en las tablas 6.5 a 6.9. Los tres enfoques expuestos fueron utilizados en las pruebas realizadas por categoría de manzana y una última en la cual se incluyen todas las categorías. A continuación se presentan las reglas utilizadas en cada una de las pruebas para la categoría Extra, I, II, III. 6.2.4 Resultados obtenidos Los resultados obtenidos por categoría se muestran a continuación. 1) Categoría extra

Regla utilizada para esta categoría:

Características :-EN_RANGO(Color_R,105,184),

EN_RANGO(Color_G,90,158), EN_RANGO(Color_B,46,65);

tallo(V),EN_RANGO(defectos_alarg_partiduras, 0 , 0 ), EN_RANGO(defectos_varios,0 , 0), EN_RANGO(defectos_moteado,0 , 0);

Categoria_extra_Golden:- Características.


86

Categoría_Extra

020406080

100

- - - R7 R5 R4 R7 R7 R7 R5 R5 R5 R4 R4 R4


Reglas

Por

cent

aje

Ejemplos Generalización

Enfoqu

Los resultados obtenidos a partir de las pruebas realizadas se muestran en la tabla 6.5.

Tabla 6.5: Resultados obtenidos en el caso de control de calidad categoría_extra

Caso (enfoque)

Reglas compiladas

Ejemplos utilizados

%

Conocimiento %

Generalización %

Unidades Ocultas Agregadas


- 100 95.95 95.94 10 1501 - 75 93.69 91.21 9 1501

a) Conexionista

- 50 91.89 90.54 7 1500 R7 - - 100 0 0 R5 - - 100 0 0

b) Simbólico

R4 - - 14.19 0 0 R7 100 96.62 96.62 29 2000 R7 75 100 95.27 13 1521 R7 50 91.89 90.54 21 2000 R5 100 95.27 95.27 20 2000 R5 75 100 95.94 20 1939 R5 50 98.65 96.62 11 2000 R4 100 91.22 91.22 21 2000 R4 75 93.69 93.24 13 2000

c) Híbrido

R4 50 94.59 94.59 19 2000

Figura 6.9: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio “calidad en

las manzanas” categoría Extra.


87

Categoría_I

020406080

100

- - - R7 R5 R4 R7 R7 R7 R5 R5 R5 R4 R4 R4


Reglas

Por

cent

aje


Enfoque

2) Categoría I


Características :-EN_RANGO(Color_R,92,145), EN_RANGO(Color_G,100,149), EN_RANGO(Color_B,40,59);

tallo(V),EN_RANGO(defectos_alarg_partiduras,0.1,0.25 ), EN_RANGO(defectos_varios,0.1 , 1), EN_RANGO(defectos_moteado,0.1 , 0.25);

Categoria_I_Golden:- Características.


Tabla 6.6: Resultados obtenidos en el caso de control de calidad categoría_I Caso

(enfoque) Reglas

compiladas Ejemplos utilizados

%

Conocimiento %

Generalización %



- 100 94.59 94.59 13 1500 - 75 95.50 89.86 10 1500

a) Conexionista

- 50 87.84 79.73 9 1500 R7 - - 100 0 0 R5 - - 100 0 0

b) Simbólico

R4 - - 30.40 0 0 R7 100 95.95 95.95 16 2000 R7 75 97.30 95.27 12 2000 R7 50 100 93.24 6 762 R5 100 93.92 93.92 20 2000 R5 75 100 97.29 14 1130 R5 50 91.89 88.51 21 2000 R4 100 92.57 92.57 24 2000 R4 75 90.09 85.81 21 2001

c) Híbrido

R4 50 100 94.59 7 1461


las manzanas” categoría I.


88

Categoría_II

020406080

100

- - - R7 R5 R4 R7 R7 R7 R5 R5 R5 R4 R4 R4


Reglas

Por

cent

aje


Enfoque

3) Categoría II

Regla utilizada para esta categoría: Características:-EN_RANGO(Color_R,95,133), EN_RANGO(Color_G,110,138), EN_RANGO(Color_B,44,61);

tallo(F),EN_RANGO(defectos_alarg_partiduras,2.1,4 ), EN_RANGO(defectos_varios,1.1 , 2.5), EN_RANGO(defectos_moteado,0.26 , 1);

Categoria_II_Golden:- Características. Los resultados obtenidos a partir de las pruebas realizadas se muestran en la tabla 6.7.

Tabla 6.7: Resultados obtenidos en el caso de control de calidad categoría_II Caso

(enfoque) Reglas


%

Conocimiento %

Generalización %



- 100 87.16 87.16 19 1500 - 75 91.89 85.81 17 1500

a) Conexionista

- 50 77.03 64.86 11 1501 R7 - - 100 0 0 R5 - - 100 0 0

b) Simbólico

R4 - - 100 0 0 R7 100 74.32 75 33 2000 R7 75 86.49 77.03 25 2000 R7 50 87.84 79.05 13 2000 R5 100 67.56 67.56 10 2001 R5 75 71.17 70.27 28 2001 R5 50 89.19 73.65 21 2000 R4 100 68.24 68.24 13 2001 R4 75 80.18 75 16 2000

c) Híbrido

R4 50 81.08 70.27 7 2000


las manzanas” categoría II.


89

4) Categoría III


Características:-EN_RANGO(Color_R,99,145), EN_RANGO(Color_G,98,139), EN_RANGO(Color_B,32,62);

tallo(F),EN_RANGO(defectos_alarg_partiduras,4.1,6 ), EN_RANGO(defectos_varios,2.6 , 5), EN_RANGO(defectos_moteado,1.1 , 2.5);

Categoria_III_Golden:- Características.


Tabla 6.8: Resultados obtenidos en el caso de control de calidad categoría_III Caso

(enfoque) Reglas


%

Conocimiento %

Generalización %



a) Conexionista - 100 89.86 90.54 17 1500 - 75 96.40 85.81 15 1500 - 50 94.59 85.81 11 1500 b) Simbólico R7 - - 100 0 0 R5 - - 100 0 0 R4 - - 29,72 0 0 c) Híbrido R7 100 95.95 95.95 19 1500 R7 75 96.40 89.19 11 1500 R7 50 90.54 86.49 10 1500 R5 100 88.51 88.51 17 1500 R5 75 96.40 89.86 8 1500 R5 50 90.54 83.78 6 1500 R4 100 91.89 91.89 15 1500 R4 75 95.50 89.86 10 1500 R4 50 95.95 86.49 8 1500


90

Categoría_III

020406080

100

- - - R7 R5 R4 R7 R7 R7 R5 R5 R5 R4 R4 R4


Reglas

Por

cent

aje


Enfoque

Figura 6.12: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio “calidad en las manzanas” categoría III.

5) Categoría Extra,I,II,III

Reglas utilizadas para todas las categorías: 1) Categoria_extra:-EN_RANGO(Color_R,105,184),

EN_RANGO(Color_G,90,158),EN_RANGO(Color_B,46,65), tallo(V),EN_RANGO(defectos_alarg_partiduras,0,0 ),

EN_RANGO(defectos_varios,0,0), EN_RANGO(defectos_moteado,0,0);

2) Categoria_I:- EN_RANGO(Color_R,92,145), EN_RANGO(Color_G,100,149),EN_RANGO(Color_B,40,59),

tallo(V),EN_RANGO(defectos_alarg_partiduras,0.1,2), EN_RANGO(defectos_varios,0.1,1),

EN_RANGO(defectos_moteado,0.1,0.25);

3) Categoria_II:-EN_RANGO(Color_R,95,133), EN_RANGO(Color_G,110,138),EN_RANGO(Color_B,44,61), tallo(F),EN_RANGO(defectos_alarg_partiduras,2.1,4),

EN_RANGO(defectos_varios,1.1,2.5), EN_RANGO(defectos_moteado,0.26,1); 4) Categoria_III:-EN_RANGO(Color_R,99,145),

EN_RANGO(Color_G,98,139),EN_RANGO(Color_B,32,62), tallo(F),EN_RANGO(defectos_alarg_partiduras,4.1,6), EN_RANGO(defectos_varios,2.6,5),

EN_RANGO(defectos_moteado,1.1,2.5).



91

Categoría_Extra, I, II, III

020406080

100

- - - - R7 R5 R4 R7 R7 R7 R5 R5 R5 R4 R4 R4


Reglas

Por

cent

aje


Enfoque

Tabla 6.9: Resultados obtenidos en el caso de control de calidad de las 4 categorías Caso

(enfoque) Reglas


%

Conocimiento %

Generalización %



a) Conexionista - 100% 62.84% 63.51% 24 1500 - 75% 87.34% 73.65% 18 1500 - 50% 79.73% 60.81% 12 1500 - 25% 70,68 50,67 8 1500 b) Simbólico R7 - - 100% 0 0 R5 - - 100% 0 0 R4 - - 0,00% 0 0 c) Híbrido R7 100 61.41 61.41 24 1500 R7 75 82,88 73,65 12 1500 R7 50 94,59 74,32 16 1500 R5 100 67.57 67.57 19 1500 R5 75 75.68 66.22 18 1500 R5 50 93.24 72.29 17 1500 R4 100 62.16 62.16 22 1500 R4 75 81.08 70.27 18 1500 R4 50 78.38 63.51 11 1500 Figura 6.13: Porcentaje de generalización entre los diferentes enfoques en el caso de estudio “calidad en

las manzanas” Todas las categorías.


92


-4

-20

24

68

10

12

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA100EJR7_100

100EJR7_75

100EJR7_50

100EJR5_100

100EJR5_75

100EJR5_50

100EJR4_100

100EJR4_75

100EJR4_50


-14

-12-10

-8-6

-4-2

0

2

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

75EJR7_100

75EJR7_75

75EJR7_50

75EJR5_100

75EJR5_75

75EJR5_50

75EJR4_100

75EJR4_75

75EJR4_50

Figura 6.14: Porcentaje de generalización entre el enfoque conexionista con 100 ejemplos y el enfoque

híbrido de la calidad en las manzanas “categoría Extra, I, II y III”.




93


02468

10121416

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

50EJR7_100

50EJR7_75

50EJR7_50

50EJR5_100

50EJR5_75

50EJR5_50

50EJR4_100

50EJR4_75

50EJR4_50


0

5

10

15

20

25

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

25EJR7_100

25EJR7_75

25EJR7_50

25EJR5_100

25EJR5_75

25EJR5_50

25EJR4_100

25EJR4_75

25EJR4_50






94


-50

-40

-30

-20

-10

01

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IAR7_R7100

R7_R775

R7_R750

R7_R5100

R7_R575

R7_R550

R7_R4_100

R7_R475

R7_R450


-50

-40

-30

-20

-10

01

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

R5_R7100

R5_R775

R5_R750

R5_R5100

R5_R575

R5_R550

R5_R4_100

R5_R475

R5_R450

Figura 6.18: Porcentaje de generalización entre el enfoque simbólico con R7 y el enfoque híbrido de la

calidad en las manzanas “categoría Extra, I, II y III”.


calidad en las manzanas “categoría Extra, I, II y III”.


95


01020304050607080

1

HÍBRIDO

PO

RC

EN

TAJE

DE

D

IFE

RE

NC

IA

R4_R7100

R4_R775

R4_R750

R4_R5100

R4_R575

R4_R550

R4_R4_100

R4_R475

R4_R450


calidad en las manzanas “categoría Extra, I, II y III”. 6.2.5 Análisis de resultados A continuación se presenta el análisis de los resultados obtenidos.

1. Categoría Extra. En esta prueba se puede observar (ver tabla 6.5) que haciendo una comparación entre el caso a) utilizando el 100% de ejemplos y el caso c) utilizando el total de los atributos (R7) y el 100% de ejemplos, se obtienen una mejor porcentaje de generalización en el enfoque híbrido. Comparando el caso a) 75% de ejemplos y el caso c) R7, R5, R4 y el 75% de ejemplos respectivamente, se obtiene un mejor porcentaje de generalización en el enfoque híbrido que en el enfoque conexionista. Así también se observa que comparando el caso b) con la utilización de la regla con 4 atributos y el caso c) R4 con 100%, 75% y 50% de los ejemplos se obtiene un mucho mejor porcentaje de generalización en la parte híbrida.

2. Categoría I. En esta prueba se puede observar (ver tabla 6.6) que haciendo una

comparación entre el caso a) utilizando el 100% de ejemplos y el caso c) utilizando R7, R5 y el 100% de ejemplos respectivamente, se obtienen una mejor porcentaje de generalización en el enfoque híbrido. Comparando el caso a) 75% de ejemplos y el caso c) R7, R5, y el 75% de ejemplos respectivamente, se obtiene un mejor porcentaje de generalización en el enfoque híbrido. En el caso a) con el 50% de ejemplos y el caso c) con R7, R5, R4 y el 50% de ejemplos se obtiene un porcentaje mayor en el caso híbrido. Por último comparando el caso b) con la regla con 4 atributos y el caso c) R4 con 100%, 75% y 50% de los ejemplos se obtiene un mucho mejor porcentaje de generalización en la parte híbrida.


96

3. Categoría II. Se observa (ver tabla 6.7) que comparando el caso a) utilizando el 50% de ejemplos y el caso c) utilizando R7, R5, R4 y el 50% de ejemplos respectivamente, se obtienen una mejor porcentaje de generalización en el enfoque híbrido.

4. Categoría III. Observe (ver tabla 6.8) que comparando el caso a) utilizando el 100%

de ejemplos y el caso c) utilizando R7, R4 y el 100% de ejemplos respectivamente, se obtienen una mejor porcentaje de generalización en el enfoque híbrido. Comparando el caso a) 75% de ejemplos y el caso c) R7, R5, R4 y el 75% de ejemplos respectivamente, se obtiene un porcentaje de generalización más alto en el enfoque híbrido. En el caso a) con el 50% de ejemplos y el caso c) con R7, R4 y el 50% de ejemplos se obtiene una mejora en el porcentaje en el caso híbrido. Comparando el caso b) con la regla con 4 atributos y el caso c) R4 con 100%, 75% y 50% de los ejemplos se obtiene un mucho mejor porcentaje de generalización en la parte híbrida.

5. Categoría Extra, I, II, III. Observe (ver tabla 6.9) que comparando el caso a)

utilizando el 100% de ejemplos y el caso c) utilizando R5 y el 100% de ejemplos, aún cuando sólo utilizamos cinco de los siete atributos se obtiene un mejor porcentaje de generalización en el enfoque híbrido. Otra observación importante es que en el caso a) con tal solo el 50% de ejemplos y el caso c) con R7, R5 y R4 los porcentajes son mucho mejor en la parte híbrida. Para terminar entre el caso b) con R4 y el caso c) R4 con 100%, 75% y 50% de los ejemplos se obtiene un porcentaje considerable de generalización en la hibridación.

6.2.6 Análisis interno de la RNA antes y después del “refinamiento” Existen algunos casos en los cuales los pesos son modificados, por ejemplo, las ligas correspondientes a las neuronas que representan los atributos adicionados por el usuario. Por el otro lado también se hace una modificación al bias que corresponde a la salida de la red neuronal artificial. Para todos las demás ligas entre neuronas el valor de pesos permanece constante antes y después del refinamiento. Como podrá observar dentro de las comparaciones entre el sistema conexionista y el sistema híbrido el único caso en el cual el sistema híbrido falla por completo es cuando se maneja el 75% de los ejemplos. No obstante cuando se trata del sistema simbólico comparado con el sistema híbrido, el sistema simbólico resulta tener mejores resultados cuando se maneja el total de reglas y la regla representada por R5 sucediendo lo contrario con la regla representada por R4. Por ello se entiende que el sistema que en este caso necesita de ser complementado es el sistema conexionista.

CAPÍTULO 7 CONCLUSIONES En este capítulo se muestran las conclusiones obtenidas en este trabajo así como las aportaciones y los trabajos futuros que se recomiendan. 7.1 Conclusiones generales A partir de los objetivos propuestos para este trabajo de tesis se concluye lo siguiente: Se implementó un sistema híbrido neuro-simbólico el cual es capaz de integrar tanto el conocimiento simbólico obtenido de un experto humano como el conocimiento numérico obtenido de una base de datos. Ésta integración permitió que ambos tipos de conocimiento se complementaran para obtener a veces mejores resultados, demostrando los casos donde es mejor integrar dos tipos de representaciones que trabajarlas en forma separada. Este sistema es capaz de mapear un conjunto de reglas simbólicas las cuales se traducen a una RNA la cual se entrena y aprende a partir de los conocimientos obtenidos para el reconocimiento de la calidad de los objetos, tal es el caso de estudio del problema de la calidad visual en las manzanas. La implementación de la teoría de los sistemas híbridos neuro-simbólicos dentro del área de la visión artificial, ayuda a tener una herramienta más para perfeccionar los sistemas desarrollados en torno a problemas de control de calidad de los objetos. 7.2 Lecciones aprendidas Las lecciones aprendidas se exponen a continuación:

• Dificultad al obtener las reglas simbólicas a partir de fuentes estáticas, ya que no existen muchas fuentes para obtener la información. Por lo tanto se tuvo que hacer un estudio de campo a un pueblo llamado Tetela de Ocampo con la finalidad de conocer la forma en la cual el experto humano realiza su trabajo para verificar la calidad de la manzana Golden Delicius.

• Utilizar un sistema analizador gramatical para poder realizar la estructura del

archivo simbólico de entrada (ANTLR), fue tardado utilizando alrededor de tres semanas, pero se invirtió menos tiempo que si se tratara de programar un analizador léxico-sintáctico.

Capítulo 7 Conclusiones

98

• Compilar reglas simbólicas a una red neuronal artificial, ya que anteriormente no tenía ni idea de cómo se podía realizar este mapeo.

• Contar con un sistema que extrae las características fue difícil ya que no se tiene

actualmente un sistema de visión completo que permita obtenerlas de manera automática y tomo alrededor de un mes el crear la base numérica de las manzanas.

7.3 Aportaciones Las aportaciones del sistema fueron las siguientes:

• Implementación del sistema híbrido neuro – simbólico en un problema de visión artificial (caso de estudio en la calidad de las manzanas).

• Utilización y comprobación de la teoría de los SHNS.

• Implementación de la metodología para la compilación de reglas simbólicas a una

RNA.

• Agregación de atributos en la red neuronal que no se encuentran en las reglas pero que son necesarios para la integración con la base de conocimientos.

• Inserción del conocimiento del experto humano en un sistema, excluido en varias

ocasiones en el desarrollo de otros sistemas.

• Exploración de otras áreas de la inteligencia artificial como los sistemas basados en conocimiento dentro del grupo de visión artificial (CENIDET).

• Creación de un ambiente el cual permite interactuar en forma más amigable con el

usuario.

• Creación de una interfaz al MS-DOS la cual permite que se establezca en forma más directa la interacción con el sistema Neusim.

• Creación de una base numérica de manzanas.

• Obtención de reglas que definen la calidad de las manzanas a partir de fuentes

estáticas y dinámicas, aún por validar por el experto humano.

• Incluir en el archivo de entrada los atributos adicionados por el usuario de tal forma que todas los atributos utilizados en la reglas y en la base de ejemplos puedan obtener un conocimiento más completo.

• Almacenamiento del conocimiento de un experto humano dentro de una red

neuronal artificial.

Capítulo 7 Conclusiones

99

7.4 Trabajos futuros A corto plazo

• Se propone realizar mas experimentos con casos más grandes, es decir que se incluya un número mayor de reglas.

• Probar con reglas dichas por expertos humanos. • Se propone el manejo de datos y/o reglas difusas para casos en los cuales las

características del problema no puedan ser abordadas en forma precisa.

• Se propone crear un ambiente gráfico para observar la RNA obtenida por el compilador que pudiera ser usada con fines didácticos.

A largo plazo

• Se propone crear un sistema con las características que posee el sistema empleado en esta tesis (Neusim) para llevar a cabo la integración de conocimientos, para tener nuestra propia herramienta.

• Se propone la extracción del conocimiento y la obtención de las reglas refinadas.

• Integrar esta herramienta en un sistema más complejo en el cual se extraigan las

reglas refinadas y validadas por el experto humano, para finalmente formar parte de un sistema de inspección visual industrial.

ANEXO A BIBLIOGRAFÍA GENERAL [Arevian-2003] Arevian G., Wermter S., Panchev C. Symbolic state transducers and recurrent neural preference machines for text mining. International Journal on Approximate Reasoning, Vol. 32, No. 2/3, pp. 237-258, 2003. [Bench-1990] Bench-Capon, T.J.M. Knowledge representation: an approach to artificial intelligence. Londres: Academic Press, 221 p.1990. [Corchado-1999] Corchado J. M. Neuro-Symbolic model for real-time forecasting problems . Dept. of Computing and Information Systems, University of Paisley, United Kingdom. PH. D. thesis, Dec 1999. [FAO/WHO-1997] FAO/WHO. Codex alimentarius food hygiene basic texts. Joint. FAO/WHO Food Standards Programme, Codex Alimentarius Commission.Pub. # M-83. 1997. [Fernández-2000] Fernández - Riverola Florentino, M. Corchado Juan. Sistemas híbridos neuro-simbólicos: una revisión. Dpto. de informática. Universidad de Vigo, Salamanca, 2000. [Fletcher-1994] Fletcher, Justin B.A. Constructive approach to hybrid architectures for machine learning. Ph. D. Thesis Washington State University, 1994. [Fuentes -2003] Fuentes Covarrubias Ricardo. Sistema de visión artificial para el control de calidad del melón. Facultad de ingeniería mecánica y eléctrica – Universidad de Colima, 2003. [Giacometi-1992] Giacometi, A. Modèles hybrides de l'expertise. PhD Thesis, LIFIA-IMAG, Grenoble - France, November,1992. [González-1996] González, Rafael C., Woods Richard. Tratamiento digital de imágenes, Addisson – Wesley Iberoamericana,1996. [González-2004] González Hdez. Edgardo. Monitor genético para la explicitación del conocimiento en un SVA. Tesis en desarrollo, Cenidet, 2004. [Hart-1992] Hart, Anna. Knowledge acquisition for expert systems . McGraw-Hill, 2ª ed. Estados Unidos,1992.

Anexo A Referencias

101

[Hayashi-1991] Hayashi, Y. A neural expert system with automated extraction of fuzzy if-then rules and its application to medical diagnosis. In advances in neural information processing systems. R. Lippmann, J. Moody, & D. Touretzky (eds.), San Mateo, CA: Morgan Kaufmann (Vol. 3).1991. [Henao-1998] Mónica Henao Cálad. La adquisición del conocimiento dentro de la ingeniería del conocimiento. Revista Universidad Eafit. Abril-Mayo- Junio, 1998. [Hernández-2003] Alejandro HumbertoVargas R. Leonardo Hernández Manizales. Aplicaciones de la inteligencia artificial en problemas de producción. Publicado Tuesday 16 de September de 2003. [Kendal-2003] Kendal K., Ashton K., Chen X. A brief overview of hym: a methodology for the development of hybrid intelligent information systems. 15th Int. Conf. on Software Engineering and Knowledge Engineering, San Francisco, July 2003. [Lochr-2000] Peter Locht, Ph.D., Dimac. Full-color space image analysis of food Products Using the WinGrain System.2000. [López-2000] Royman López Beltrán. Edgar Sotter Solano. Eduardo Zurek Varela.Operación automática de control de calidad usando un sistema de visión por computador. Laboratorio de Robótica y Producción Automática. Universidad del Norte. [email protected], [email protected]. [Magadán-1999] Magadán Salazar Andrea. Reconocimiento de rostros invariante a expresiones facials. Tesis de maestría, Centro nacional de investigación y desarrollo tecnológico (cenidet), Cuernavaca, Morelos, noviembre. 1999. [McGarry-2002] McGarry K., MacIntyre J. Knowledge transfer between neural networks, proceedings of the sixteenth european meeting on cybernetics and systems research. Vienna, Austria, pp. 555-560, April 2002. [Medsker-1992] Medsker L. R. y Bailey D. L. Models and guidelines for integrating expert systems and neural networks. Hybrid Architectures for Intelligent Systems. Ed. Kandel A. y Langholz G. CRC Press, Boca Raton. 1992. [Moctezuma-2004] Moctezuma Isidro. Grupo de visión artificial. Trabajo de investigación, periodo agosto-diciembre, 2003. Centron nacional de investigación y desarrollo tecnológico, CENIDET. México, 2003. [Osorio-2002] Osorio F.S. Constructive machine learning: A new neuro-symbolic approach. UNISINOS – Computer Science Dept.- C6 Av. Unisinos, 950 – CP 275 – CEP 930022-000 RS- Brazil, 2002.

Anexo A Referencias

102

[Osorio-2001] Osorio, F. S., AMY, Bernard. Aprendizado de máquinas: métodos para inserção de regras simbólicas em redes neurais artificiais aplicados ao controle em robótiva autônoma. Revista SCIENTIA, Vol. 12, Nro. 1, p.1-20. Editora da Unisinos, Out. 2001. [Osorio-1998] Osorio F.S. INSS: an hybrid system for constructive machine learning. Laboratoire LEIBNIZ – IMAG –INPG 46, avenue Félix Viallet 38031 Grenoble Cedex 1 –FRANCE, 1998. [Pla-2002] Pla Bañón Filiberto. Desarrollo de sensores de visión y su aplicación al control distribuido de calidad de frutos. FEDER-CICYT. Ministerio de Educación y Cultura. 2002. [Rashad-2001] Rashad U., Arullendran P., Hawthorne M., Kendal S. A hybrid medical information system for the diagnosis of dizziness. Proceedings 4th International Conference Neural Networks and Expert Systems in Medicine and Healthcare. Greece, June 2001. [Reyes-1995] Gerardo Reyes Salgado. Adquisición automática de conocimietno para sistemas expertos. Tesis. Centro Nacional de investigación y Desarrollo Tecnológico(CENIDET). Cuernavaca, Morelos, México.1995. [Reyes-2003] Gerardo Reyes Salgado, Vianey Guadalupe Cruz Sánchez. Extracción de reglas simbólicas para refinar conocimiento en un sistema híbrido neuro-simbólico. Centro Nacional de investigación y Desarrollo Tecnológico(CENIDET). Cuernavaca, Morelos, México, 2003. [Szczesniak-1997] Szczesniak, A.S. An overview of recent advances in food texture research. Food Technol. 31(4): 71-75, 1977. [Sun-1995] Sun, Ron ; Bookman, J. L.(1995) Computational architectures integrating neural and symbolic processes. Kluwer Academic Publishers, Boston, MA. E.U. 1995.

[Symons-2002] Symons Hall. Mejorando la seguridad y calidad de frutas y hortalizas frescas: Manual de formación para instructores, University of Maryland, Symons Hall, College Park, MD 20742, 2002. [Terence-2003] Terence Parr. An introduction to ANTLR. Another tool for language recognition, 2003. [Towell-1991] Towell G. Symbolic knowledge and neural networks: insertion, refinement and extraction. Ph.D. Thesis, University of Wisconsin-Madison - Computer. Science Dept. Web:http://www.cs.wisc.edu/~shavlik/uwml.html.1991. [Towell-1992] Towell G. Jude W. Shavlik. Interpretation of artificial neural networks: mapping knowledge-based neural networks into rules. Computer sciences department, University of Wisconsin – Madison, 1992.

Anexo A Referencias

103

[Thrun-1992] Thrun Sebastian: The monk’s problems. School of Computer Science, Carnegie Mellon University. Pittsburgh, PA 15213. http://www.ics.uci.edu/~mlearn/MLRepository.html. USA.1992. [Vergara-2003] Vergara Villegas Osslan Osiris. Reconocimiento de texturas artificiales, aplicación a la inspección visual. Tesis de maestría. Centro Nacional de Investigación y Desarrollo Tecnológico. Cuernavaca, Morelos. México, 2003. [Wermter-2002] Wermter S., Panchev C. Hybrid preference machines based on inspiration from neuroscience. Cognitive Systems Research. Vol. 3, No. 2, pp. 255-270, 2002. [Wermter-2000] Wermter, Stefan and Sun, Ron.(Eds.) Hybrid neural systems . Springer Heidelberg, 2000. Referencias de páginas web [1] Consejo Nacional de producción CNP dirección calidad agrícola área normas y certificación. Serie Poscosecha No. 2 Ferias del agricultor. Calidad de las frutas y hortalizas. [2] El cultivo de la manzana. Copyright infoagro.com 2003. http://www.infoagro.com/frutas/frutas_tradicionales/manzana.htm

[3] XXIII GMC - Brasilia, 11/10/96 http://www.mercosur.org.uy/espanol/snor/normativa/resoluciones/1996/RES96117.htm [4] http://www.monografias.com/trabajos12/redneur/redneur.shtml [5]http://www.infor.uva.es/~calonso/IngenieriaConocimientoCommonKADS/ CK1FundamentosIC.pdf

ANEXO B GLOSARIO DE TÉRMINOS Añero: Árbol que da fruto cada dos años. Aprendizaje: Actividad mediante la cual la información se adquiere a través de la experiencia y pasa a formar parte del repertorio de datos del organismo. Atributo/rasgo/variable/característica: Cualidad o característica que pertenece al sujeto esencial o necesariamente. Arrugamiento (shrivel): Las manzanas golden delicious son particularmente susceptibles a la pérdida de agua. ANTLR: Another Tool Language Recognition (Otra herramienta de reconocimiento de lenguajes). Backpropagation: Es un tipo de red de aprendizaje supervisado para perceptrones multicapa. Básicamente es una técnica de gradiente descendiente para minimizar el criterio de error. Calidad: Totalidad de las características y rasgos de un producto relacionados con su capacidad para satisfacer necesidades explícitas o implícitas. Cavidad calicinar o peduncular: Región que se encuentra entre el fruto y el pedúnculo. Conocimiento: Información almacenada; modelo usado por una persona o máquina para interpretar, predecir y responder apropiadamente al mundo externo. Corazón Acuoso: Disturbio caracterizado por la presencia de zonas de aspecto vitreo en la pulpa, particularmente cerca del corazón y en los haces vasculares primarios. Daño por insecto: Es toda lesión causada por insectos que al remover la epidermis a tres milímetros de profundidad afecta la pulpa. Deformación: Desviación manifiesta de la forma característica del cultivar. Enfoque simbólico: Representación y manipulación del conocimiento estructurado simbólicamente, codificado dentro de un lenguaje cercano al leguaje natural; es el punto central para el desarrollo de los sistemas basados en conocimiento (simbólicos). Las ventajas de estos sistemas es la habilidad para representar conocimiento comprensible. Los

Anexo B Glosario de términos

105

sistemas diseñados con este enfoque manejan el conocimiento del experto representándolo mediante reglas simbólicas. Enfoque conexionista: Enfoque basado en el modelo del cerebro humano. Los sistemas conexionistas (redes neuronales artificiales) son poderosas herramientas utilizadas para aprender y generalizar el conocimiento obtenido de casos prácticos. Escaldado superficial (superficial scald): Es el pardeamiento de la piel que se desarrolla en almacenamiento refrigerado. Explicitación: Expresar claramente y determinadamente una cosa. Fuji: Árbol muy vigoroso y productivo con cierto añerismo propio de la variedad. Fruto grande, con color de fondo amarillo con sobre color rojo estriado, pulpa amarillenta, crocante de muy buen sabor dulce. De muy buena conservación frigorífica. Se cosecha en Marzo. Gala: Es una variedad de origen neozelandés resultante del cruce de Kidd 's Orange con Golden Delicious, siendo su cultivo recomendable en zonas de regadío españolas. Los árboles son de producción notable y regular, precisando aclareo químico. La manzana es de coloración amarilla y conviene cosecharla a tiempo para evitar la aparición de grietas en la zona del pedúnculo. Golden Delicious (Deliciosa Dorada): El fruto es grande y de color amarillo dorado, más largo que ancho, con la carne blanca amarillenta, fija, jugosa, perfumada y muy sabrosa. El pedúnculo es largo o muy largo y la piel delgada y resistente, cubierta con lenticelas grisáceas. Es una excelente polinizadora para la mayoría de las variedades comerciales. Es sensible al mal blanco, moteado y pulgón lanígero. Resistente a chancro. Se trata de una variedad muy productiva. Fruto de buena conservación natural y en frío. Recolección en septiembre-octubre. Granny Smith: Es una variedad de origen australiano introducida en España. En Europa goza de un excelente mercado compitiendo con Golden Delicious. Los árboles son vigorosos, precoces en la fructificación y muy productivos; tienen tendencia a dar frutos en la extremidad de las ramas, por tanto es importante saber podarlas; prefiere la formación en palmeta; son algo sensibles al moteado. Se poliniza con Golden y suelen hacerse plantaciones con estas dos variedades exclusivamente.La manzana es de buen tamaño, esférica y simétrica. Tiene color verde intenso que se vuelve más claro en la madurez, con numerosas lenticelas de color blanquecino. Integración: Proceso de unificación de varias entidades. Machucamiento/Magulladora: Lesión con deformación superficial sin rotura de la epidermis provocada por la acción mecánica. Mancha: Alteración en la coloración normal de la piel de la fruta. No se considera defecto la coloración rojiza en las variedades Granny Smith y Golden.


106

Manzana: Se entiende por manzana la fruta de la especie Malus doméstica Borhk. Moteado del árbol de manzano: Es la enfermedad más grave del manzano. La enfermedad obstaculiza su desarrollo, lo deforma y agrieta. En el mejor de los casos quedan depreciados. Partidura de la Piel (skin cracking o checking): Las manzanas Fuji parecen ser susceptibles a la partidura de la piel. La causa aún no es conocida, sin embargo, una cosecha tardía incrementa la severidad de los síntomas. Pardo: Color que resulta de la mezcla del rojo, negro y amarillo o naranja. Pardeamiento interno: Alteración con pardeamiento de los tejidos internos por efecto de baja temperatura, evolucionando desde la zona media de la pulpa hacia el corazón y finalmente hacia la periferia. Pedúnculo: Término utilizado para referirse al tallo del fruto. Picado Amargo (bitter pit): Manchas pardas hundidas en la piel. Podredumbre: Daño patológico que implique cualquier grado de descomposición, desintegración o fermentación de los tejidos.

Red Delicious (Deliciosa roja): Fruto de buen tamaño, de color rojo más o menos intenso, con un punteado amarillo, carne azucarada, jugosa, ligeramente acidulada y muy aromática. Variedad de crecimiento vertical y con tendencia a dar ángulos agudos en la inserción de las ramas. Es autoestéril y de floración semi-tardía. Es un árbol muy exigente desde todos los puntos de vista, particularmente en terreno. Es sensible al moteado, araña roja y pulgón lanígero. Fruto de excelente conservación. Recolección en septiembre-octubre.

Reglas de producción: Los sistemas basados en reglas son los más comúnmente utilizados. Su simplicidad y similitud con el razonamiento humano, han contribuido para su popularidad en diferentes dominios. Las reglas son un importante paradigma de representación del conocimiento.

Estas reglas representan el conocimiento utilizando un formato SI-ENTONCES (IF-THEN).

o La parte SI (IF), es el antecedente, premisa, condición o situación; y o La parte ENTONCES (THEN), es el consecuente, conclusión, acción o respuesta.

Refinar: Perfeccionar una cosa. En esta tesis el refinamiento de una RNA se logra mediante el proceso de aprendizaje que implica cambios en los pesos de interconexión de la RNA.


107

Redes Neuronales Artificiales (RNA): Una red neuronal es la implementación de un algoritmo inspirado en el cerebro humano. Una rama de la neurociencia donde se utilizan computadoras para modelar funciones cognitivas. Dicha tecnología en la cual las computadoras aprenden directamente de datos, asistiendo en tareas de clasificación, funciones de estimación, compresión de datos y tareas similares.

Sistema de visión artificial: Es el proceso de simulación del sistema de visión humano para la creación de modelos matemáticos que permitan hacer el reconocimiento de imágenes de segundo y tercer plano. Sistemas híbridos neuro-simbólicos: Enfoque que permite combinar diferentes métodos de representación del conocimiento y sus algoritmos asociados empleados en el razonamiento. Sobremaduro: Fruto que presenta un avanzado estado de maduración o senescencia. Topología de red: Forma en la cual son hechas las conexiones en una RNA, así como la forma de conectar neuronas biológicas en el cerebro.

108

ANEXO C DETALLE DEL CÓDIGO Diagrama de funciones

Inserción de datos Ordenar String por columna y por renglón.

Compilación de reglas Verifica_regla, su duplicidad y reescribe consecuentes. Crea topología y pesos.

Obtención del archivo simbólico

Abrir

Análisis gramatical Compilación del archivo de entrada.

Corrección del archivo simbólico

Modificar y guardar modificaciones.

Verificación de antecedentes

Verifica antecedentes es decir si es una función o una premisa sencilla, valor de la neurona, tipo de neurona, almacena las neuronas, verifica atributos adicionales.

Crear topología Liga desde hasta, asigna etiqueta a neuronas, calcula el número de capas,imprime topología.

Pesos Calcula pesos y bias de acuerdo al tipo de función MAQ, MoIQ, MEQ, Meo IQ, ER, Not. Almacena los pesos e imprime su valor.

Especificación de parámetros

Inicialización de parámetros de compilación.

109

/-----------------------------------------------

---------------------------- #include <fstream.h> #include <vcl.h> #include <stdio.h> #include "fstream.h" #include "L.hpp" #include "P.hpp" #include "SHNS.h" #include "Unit2.h" #include "Unit3.h" #include "Unit4.h" #include "red.hpp" #include "Unit5.h" #include "Unit6.h" #include "compilacion_red.hpp" #include "Func_Ant.hpp" //#include "Almacena_neurona_Ent.hpp" #pragma hdrstop Inserción de datos //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma link "CSPIN" #pragma resource "*.dfm" TForm1 *Form1; fstream inout;//Nombre utilizado para el archivo simbólico char linea[120];//Se utiliza para verificar cada línea del archivo simbólico char temporal[120];//Solo se emplea como una variable temporal int tamano[120];//Se utiliza para obtener el tamaño de una cadena int j;//Variable global para ser utilizada en cualquier función int linea_fin;//Se utiliza para llevar el control de la linea actual a leer int columna;//Se utiliza para colocar la informaciòn en un columna del StringGrid int espacio;//Se utiliza para llevar el control de los espacios int size;//Variable que puede ser utilizada para el tamaño de una cadena int col;//Controla la columna int Catrib;//Variable para los atributos int temp3;//Variable Temporal int renglon;//Se utiliza para llevar el control de los renglones en el StringGrid AnsiString Cad_resc=""; vector<red> disyuncion(0);//Almacena el numero de la regla con disjunciòn vector<red> conjuncion(0);//Almacena el numero de la regla con conjunciòn red numero; //Sirve obtener el numero de la regla y manipular los vectores //Función Reordenar: (función llamada desde Reglas1click) //Sirven solo para ordenar los datos en el StringGrid correspondiente //No forma parte del algoritmo void reordenar(TStringGrid *N){ AnsiString caden1=""; AnsiString tem_al1=""; AnsiString t_al1=""; char caden2[150]; int num1=0; for(int i=1;i <= N->RowCount;i++) {

for(int j=1;j< N->ColCount;j++){ caden1=N->Cells[j][i]; int p=0; int q=0; for(int i=0; i < 150; i++){ if((caden1.c_str()[i]=='\t')||(caden1.c_str()[i]==' ')){ p++; }else{ caden2[q]=caden1.c_str()[i]; q++;} } for(int j=0; j < 150; j++){ if((caden2[j]!=' ')&&(caden2[j]!='\0')) num1++; else goto next1; } next1: for(int l=0;l < num1;l++) t_al1+= caden2[l]; N->Cells[j][i]=t_al1; tem_al1=""; t_al1=""; num1=0; caden1=""; } } } //Verifica_Regla: (función llamada desde la compilación de las reglas(Compilaci1click)) //Se encarga de calcular si la regla se trata de una disyunción char Verifica_Regla(int n){ int t=disyuncion.size(); int Temp; char T='C'; for(int i=0;i<t;i++){ Temp=disyuncion[i].Num; if(n==Temp) T='D'; } return(T); } //revisa_etiqueta:(función llamada desde la función reescribir) //Se encarga de verificar que los consecuentes ya etiquetados no sean renombrados char revisa_etiqueta(AnsiString cadena){ int size; char v; char f; size=int(cadena.Length()); if(cadena.c_str()[size-1]=='.'){ return('v'); }else return('f'); } //reescribir:(función llamada desde la compilación de las reglas(Compilaci1click)) //Se encarga de reetiquetar los consecuentes de las reglas como parte //del primer paso del algoritmo de traducción de reglas a Red void reescribir(TStringGrid *R){ AnsiString cadena =""; AnsiString temporal1 =""; AnsiString temporal2 ="";

Anexo C Detalle del código

110

AnsiString temporal3 =""; AnsiString temporal4 =""; char almacen [25]; int p=0,k; int cont=0,q; int b=0; int B=0; int P=0; int r; char E; cadena=Cad_resc; size=int(cadena.Length()); while(j < size){ if(cadena.c_str()[j]!=' '){ for(int i=j;i < size;i++){ if(cadena.c_str()[i]!=' ') { temporal1+=cadena.c_str()[i]; }else{ for(k=i+1;k < size;k++){ if(cadena.c_str()[k]!=' ') { temporal2+=cadena.c_str()[k]; } else{goto next;} } } } next: r=atoi(temporal1.c_str()); R->Cells[1][renglon]=R->Cells[1][r]; E=revisa_etiqueta(R->Cells[1][renglon]); if(E=='v'){ R->Cells[1][r]=R->Cells[1][r]+ AnsiString(cont++); R->Cells[2][renglon]=R->Cells[1][r]; numero.Num=renglon; disyuncion.push_back(numero); renglon++; } r=atoi(temporal2.c_str()); E=revisa_etiqueta(R->Cells[1][r]); if(E=='v'){ R->Cells[1][r]=R->Cells[1][r]+ AnsiString(cont++); R->Cells[2][renglon]=R->Cells[1][r]; renglon++; } p=k+1; while(p < size ){ if(p!=' '){ P=p; for(q=p;q < size;q++){ if(cadena.c_str()[q]!=' ') { temporal3+=cadena.c_str()[q]; }else{ B=q+1; for( b=q+1;b < size;b++){ if(cadena.c_str()[b]!=' ') { temporal4+=cadena.c_str()[b]; } else{goto next2;} } } } next2: if(temporal1==temporal3 && temporal1!=temporal4){ r=atoi(temporal4.c_str()); R->Cells[1][r]=R->Cells[1][r]+ AnsiString(cont++); R->Cells[2][renglon]=R->Cells[1][r]; renglon++; for(int i=P;i < q;i++){ cadena.c_str()[i]=' '; } for(int j=B;j < b;j++){

cadena.c_str()[j]=' '; } } if(temporal2==temporal3){ for(int i=P;i < q;i++){ cadena.c_str()[i]=' '; } for(int j=B;j < b;j++){ cadena.c_str()[j]=' '; } } p=b+1; temporal3=""; temporal4=""; } else{ p++; } } j=k+1; cont=0; temporal1=""; temporal2=""; } else{j++;} } R->RowCount=renglon; } //verifica_duplicidad:(función llamada desde compilar1click y Reglas1click) //Se encarga de verificar la existencia de atributos repetidos y de //consecuentes repetidos a fin de posteriormente ser retiquetados. void verifica_duplicidad(TStringGrid *N){ int j=1; AnsiString cad1=""; AnsiString cad2=""; int size=0; while(j <= N->RowCount) { cad1=(N->Cells[1][j]); size=int(cad1.Length()); if(size!=0){ for(int x=j;x < N->RowCount;x++) { if(j==x)x=x+1; cad2=(N->Cells[1][x]); if(cad1.c_str()[0]==' ') { temp3=1;goto next; } for(int i=0;i<size;i++) { if(cad1.c_str()[i]!=' ') { if(cad1.c_str()[i]!=cad2.c_str()[i]) { temp3=1; goto next; } } } next: if (temp3==0) { if(N==Form1->StringGrid1){ ShowMessage("Warning! Duplicidad de los atributos, favor de corregir: "+ AnsiString(j)+" " + AnsiString(x)); } else{ Cad_resc+= AnsiString(j)+" " + AnsiString(x)+" "; } } temp3=0; } }


111

j++; } } //Ordena_String: (función llamada desde Reglas1click) //Sirven solo para ordenar los datos en el StringGrid2.No forma parte del algoritmo void Ordena_String(){ AnsiString cad1=""; AnsiString temp=""; int size; int N=0; int n=0; char cad2[50]; for(int j=1;j <=Form1->StringGrid2->RowCount;j++) { cad1=Form1->StringGrid2->Cells[1][j]; for(int i=0;i < 50;i++) { cad2[i]=cad1.c_str()[i]; if(cad2[i]==':'){ N=1; cad1.c_str()[i]=cad2[i]='.'; } } if(N==1){ Form1->StringGrid2->Cells[1][j]=cad1; } else { for(int l=1;l < Form1->StringGrid2->ColCount;l++ ) { temp=Form1->StringGrid2->Cells[l][j]; size=int(temp.Length()); if((temp==' ')||(size==0)) { n=l; goto s; } } s: for(int m=n;m > 0;m--) { Form1->StringGrid2->Cells[m][j]=Form1->StringGrid2->Cells[m-1][j]; } Form1->StringGrid2->Cells[1][j]=" "; } N=0; n=0; size=0; } } //Ordena_String_renglon: (función llamada desde Reglas1click) //Sirven solo para ordenar los datos en el StringGrid2.No forma parte del algoritmo void Ordena_String_renglon(){ AnsiString temp; int z=0; int zz=0; for(int i=1;i<=Form1->StringGrid2->RowCount;i++ ) { for(int j=1;j < Form1->StringGrid2->ColCount;j++ ) { temp=Form1->StringGrid2->Cells[j][i]; size=int(temp.Length()); for(int p=0;p< size;p++) { if(temp.c_str()[p]!=' ')

zz=1; } if((size!=0)&& zz!=0) { z=1; } zz=0; } if(z==0) { for(int l=i;l<=Form1->StringGrid2->RowCount;l++ ) { for(int m=0;m < Form1->StringGrid2->ColCount ;m++) { Form1->StringGrid2->Cells[m][l]=Form1->StringGrid2->Cells[m][l+1]; } } } z=0; } renglon=Form1->StringGrid2->RowCount; } void Fun_obtener_nombre(AnsiString obtiene_ruta){ AnsiString Cadena; int size=int(obtiene_ruta.Length()); size=size-4; for(int i=size; i > 0;i--){ if(obtiene_ruta[i] != '\\'){ Cadena= Cadena + obtiene_ruta[i]; }else{ goto fin; } } fin:; int tam=int(Cadena.Length()); for(int i=tam; i > 0;i--) Form1->Nombre=Form1->Nombre + Cadena[i]; } //--------------------------------------------------------------------------- __fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) { Memo1->Text = ""; Memo2->Text = ""; Compilacin1->Enabled=false; //Inicializa el valor del peso a 4.0 según KBANN de Towell //Se consideran los mismos valores para cada uno de los parámetros factor_w_constante = 4.0; //valor de peso por default Valor_Confianza = 10.0;//El valor de confianza y sensibilidad Valor_Sensibilidad = 0.0; //Sirven para efectos de tener un margen de error en la red } //--------------------------------------------------------------------------- Obtención del archivo simbólico //Abrir1Click: /*Abre el archivo a través de un OpenDialog donde se le indica la ruta en la que se encuentra el archivo simbólico.*/ AnsiString ruta; AnsiString Archivo_Simbolico; void __fastcall TForm1::Abrir1Click(TObject *Sender)


112

{ Memo1->Text = ""; Memo2->Text = ""; Memo1->ReadOnly = true; Memo2->ReadOnly = true; if(OpenDialog1->Execute()){//inicio if try{ inout.open(OpenDialog1->FileName.c_str()); } catch(...) { ShowMessage("No se puede abrir el archivo"); } } ruta=OpenDialog1->FileName; Fun_obtener_nombre(ruta); inout.close(); Memo1->Lines->LoadFromFile(OpenDialog1->FileName); GroupBox2->Caption="Compilación del Archivo Simbólico"; } //--------------------------------------------------------------------------- //Cerrar1Click: //Termina la aplicación y se sale del programa void __fastcall TForm1::Cerrar1Click(TObject *Sender) { Application->Terminate(); } //--------------------------------------------------------------------------- Análisis gramatical del archivo simbólico //Compilar1Click: //Esta parte se encarga de analizar la estructura del archivo simbólico, es decir //la estructura gramatical que tiene el archivo de entrada void __fastcall TForm1::Compilar1Click(TObject *Sender) { DeleteFile(Form1->Nombre_top); DeleteFile(Form1->Nombre_wts); DeleteFile(Form1->Nombre_rep); TForm2 *Form2; Form2 = new TForm2(this); //Se ejecuta el análisis léxico y sintáctico del archivo simbólico. inout.open(OpenDialog1->FileName.c_str()); L lexer(inout); P parser(lexer); parser.starRule(); _temp=parser.Regresa_Error();//Regresa el numero de errores encontrados _atri=parser.Regresa_Natri();//Regresa el numero de atributos o caracteristicas _regl=parser.Regresa_NReglas();//Regresa el numero de reglas en el archivo inout.close(); /*Abre el archivo ErroresDecompilacion que contiene los errores de la compilación y los carga en el objeto Memo2 para su visualización, también se visualizan en Form2*/ Memo2->Lines->LoadFromFile("ErroresDeCompilacion.dat"); Form2->Label1->Caption="ArchSimb: " + OpenDialog1->FileName; Form2->Label2->Caption="Numero de Reglas: " + AnsiString(_regl); Form2->Label3->Caption="Numero de Atributos: " + AnsiString(_atri);

Form2->Label4->Caption="Errores: " + AnsiString(_temp); Form2->ShowModal(); /* Carga de Atributos en el StringGrid1 */ /* Esta parte solo se encarga de colocar la información de los atributos en el StringGrid1 asi como los atributos adicionales. También se llama la función reordenar() para ordenar la información y posteriormente la función verificar_duplicidad(). También es llamada la función Reglas1Click(). */ //Si _temp: el numero de errores es cero, entonces se cargan los atributos y la reglas //en el StringGrid1 y StringGrid2. if(_temp==0){ j = 0; linea_fin = 1; columna = 1; espacio = 0; Catrib = 0; col = 1; AnsiString cad = ""; AnsiString temp = ""; AnsiString cad_temp = ""; for(int i=0;i<120;i++) temporal[i]=' '; inout.open(OpenDialog1->FileName.c_str()); while((!inout.eof())&& cad_temp!="#REGLAS"){//inicio while inout.getline(linea,120);//obtiene la linea del archivo cad_temp=AnsiString(linea);//asigna la linea a una cadena if(cad_temp=="#ATRIBUTOS"){ while(!inout.eof()&& cad!="#FIN_ATRIBUTOS"){ inout.getline(linea,120);//obtiene la linea del archivo cad=AnsiString(linea);//asigna la linea a una cadena size=int(cad.Length());//obtiene la longitud de la cadena if(cad=="#FIN_ATRIBUTOS"){goto fin;} for(int i=0;i<=size;i++){//inicio for if((cad.c_str()[i]!='\0')&&(cad.c_str()[i]!=':')&&(cad.c_str()[i]!=',')&& (cad.c_str()[i]!=';')&& (cad.c_str()[i]!='.')&&(cad.c_str()[i]!='[')&& (cad.c_str()[i]!=']')){//inicio if temporal[j]=cad.c_str()[i];//Asigna una palabra a un arreglo temporal if(columna == 1 ){ //solo para eliminar los espacios en la primer columna if(temporal[j]!=' ') j++; }else{ j++; } espacio=0; }//end_if else{//inicio else espacio++; if(espacio <=1 ){//inicio if StringGrid1->Cells[columna][linea_fin]=temporal;//vacia la cadena al StringGrid for(int i=0;i<j;i++)//inicio for temporal[i]=' '; columna++;


113

if(columna > col){//inicio if StringGrid1->ColCount=columna;//asigna la columna max. col=columna; }//fin if j=0; }//fin for }//fin de if }//fin else columna=1; j=0; linea_fin++;//Incrementa la linea StringGrid1->RowCount=linea_fin; }//fin for }//fin if fin: }//fin del while inout.close();//Cierra el archivo en cuestión linea_fin=linea_fin-1; StringGrid1->RowCount=linea_fin; //Obtener el num.de renglon a partir de donde se obtendrán los Atributos_Adicionales. Num_Renglon_Atributos_Adicionales=linea_fin-1; inout.open(OpenDialog1->FileName.c_str()); while((!inout.eof())){//inicio while inout.getline(linea,120);//obtiene la linea del archivo cad_temp=AnsiString(linea);//asigna la linea a una cadena if(cad_temp=="#ATRIB_ADIC_USUARIO"){ while(!inout.eof()&& cad!="#FIN"){ inout.getline(linea,120);//obtiene la linea del archivo cad=AnsiString(linea);//asigna la linea a una cadena size=int(cad.Length());//obtiene la longitud de la cadena if(cad=="#FIN"){goto fin2;} for(int i=0;i<=size;i++){//inicio for if((cad.c_str()[i]!='\0')&&(cad.c_str()[i]!=':')&&(cad.c_str()[i]!=',')&& (cad.c_str()[i]!=';')&& (cad.c_str()[i]!='.')&&(cad.c_str()[i]!='[')&& (cad.c_str()[i]!=']')){//inicio if temporal[j]=cad.c_str()[i];//Asigna una palabra a un arreglo temporal if(columna == 1 ){ //solo para eliminar los espacios en la primer columna if(temporal[j]!=' ') j++; }else{ j++; } espacio=0; }//end_if else{//inicio else espacio++; if(espacio <=1 ){//inicio if StringGrid1->Cells[columna][linea_fin]=temporal;//vacia la cadena al StringGrid for(int i=0;i<j;i++)//inicio for temporal[i]=' '; columna++; if(columna > col){//inicio if StringGrid1->ColCount=columna;//asigna la columna max. col=columna; }//fin if

j=0; }//fin for }//fin de if }//fin else columna=1; j=0; linea_fin++;//Incrementa la linea StringGrid1->RowCount=linea_fin; }//fin for }//fin if fin2: }//fin del while StringGrid1->RowCount=linea_fin; inout.close();//Cierra el archivo en cuestión //Visualiza los datos en el StringGrid1 for(int i=1;i <StringGrid1->RowCount;i++){ StringGrid1->Cells[0][i]=i; StringGrid1->ColWidths[0]=20; } for(int i=3;i <StringGrid1->ColCount;i++) StringGrid1->Cells[i][0]="Valor"; StringGrid1->Cells[1][0]="ATRIBUTOS"; StringGrid1->Cells[2][0]="TIPO"; reordenar(Form1->StringGrid1);//Limpia el StringGrid1 de tabs,etc. verifica_duplicidad(Form1->StringGrid1);//Verifica la duplicidad de atributos Reglas1->Click();//Se procede a cargar las reglas en el StringGrid2 } //Si _temp fue diferente de cero, entonces los atributos y reglas no se muestran else{ for(int i=0;i < StringGrid1->ColCount;i++){ for(int j=0;j < StringGrid1->RowCount;j++){ StringGrid1->Cells[i][j]=' '; } } for(int i=0;i < StringGrid2->ColCount;i++){ for(int j=0;j < StringGrid2->RowCount;j++){ StringGrid2->Cells[i][j]=' '; } } ShowMessage("Archivo Simbólico incorrecto, atributos y reglas no se muestran"); } } //--------------------------------------------------------------------------- Corrección del archivo simbólico //Modificar1Click: //Permite hacer los cambios desde el sistema al archivo simbólico void __fastcall TForm1::Modificar1Click(TObject *Sender) { //Permite realizar modificaciones en el archivo simbólico Memo1->ReadOnly=false; } //--------------------------------------------------------------------------- //GuardarModificaciones1Click: //Se encarga de guardar los cambios realizados en el archivo simbólico void __fastcall TForm1::GuardarModificaciones1Click(TObject *Sender) {


114

//Graba el archivo simbólico una vez hechas las modificaciones if(SaveDialog1->Execute()) Memo1->Lines->SaveToFile(SaveDialog1->FileName); Memo1->ReadOnly=true; //Borra el archivo que contiene los errores de la compilación DeleteFile("ErroresDeCompilacion.dat"); } //--------------------------------------------------------------------------- /*Reglas1Click:(Esta función es llamada desde Compilar1click) Se encarga de colocar la información en el StringGrid2 de tal forma que posteriormente se pueda manipular la información de las reglas desde el.*/ void __fastcall TForm1::Reglas1Click(TObject *Sender) { int tamC=0; int numC=0; int c =0; j = 0; linea_fin = 1; columna = 1; espacio = 0; AnsiString cad=""; AnsiString temp=""; AnsiString cad_temp=""; int n=0; for(int i=0;i<120;i++) temporal[i]=' '; inout.open(OpenDialog1->FileName.c_str()); int bandera=0; while(!inout.eof() && cad_temp!="#FIN"){//inicio while inout.getline(linea,120);//obtiene la linea del archivo cad_temp=AnsiString(linea);//asigna la linea a una cadena if(cad_temp=="#REGLAS"){ while(!inout.eof()&& cad!="#FIN_REGLAS"){ inout.getline(linea,120);//obtiene la linea del archivo cad=AnsiString(linea);//asigna la linea a una cadena size=int(cad.Length());//obtiene la longitud de la cadena if((cad==' ')||(size==0)){n=1;} if(cad=="#FIN_REGLAS"){goto fin;} for(int i=0;i<=size;i++){//inicio for if(cad.c_str()[i]=='(')bandera=1; if((cad.c_str()[i]!='\0')&&(cad.c_str()[i]!=',')&&(cad.c_str()[i]!='-') &&(cad.c_str()[i]!=';')&& (cad.c_str()[i]!='.')&&(cad.c_str()[i]!='(')&& (cad.c_str()[i]!=')')){//inicio if if(cad.c_str()[i]=='(')bandera=1;//control de la sintaxis temporal[j]=cad.c_str()[i];//Asigna una palabra a un arreglo temporal if(columna == 1 ){ //solo para eliminar los espacios en la primer columna if(temporal[j]!=' ') j++; }else{ j++; } if(j > tamC){tamC = j;} espacio=0; }//end_if else{//inicio else

espacio++; if(espacio <=1 ){//inicio if StringGrid2->Cells[columna][linea_fin]=temporal;//vacia la cadena al StringGrid for(int i=0;i<j;i++)//inicio for temporal[i]=' '; columna++; if(columna > numC){numC=columna;} if(columna > col){//inicio if StringGrid2->ColCount=columna;//asigna la columna max. col=columna; }//fin if j=0; }//fin if }//fin de if if(((cad.c_str()[i]==')')&&(cad.c_str()[i+1]==','))|| ((cad.c_str()[i]==')')&&(cad.c_str()[i+1]==';'))|| ((cad.c_str()[i]==')')&&(cad.c_str()[i+1]=='.'))|| ((cad.c_str()[i]!=')')&&(cad.c_str()[i+1]==',')&& (bandera!=1))|| ((cad.c_str()[i]!=')')&&(cad.c_str()[i+1]==';')&& (bandera!=1))|| ((cad.c_str()[i]!=')')&&(cad.c_str()[i+1]=='.')&& (bandera!=1))) {columna=2;linea_fin++;bandera=0;} }//fin else columna=1; j=0; c=0; if(n==1){ linea_fin=linea_fin; }else{ linea_fin++;//Incrementa la linea } n=0; StringGrid2->RowCount=linea_fin; }//fin while }//fin if fin: }//fin del while inout.close();//Cierra el archivo en cuestión //Visualiza los datos en el StringGrid StringGrid2->RowCount=linea_fin-1; StringGrid2->ColCount=numC; /* Agrega las reglas, si existen, del archivo de reglas incluido*/ fstream reglas; j = 0; columna = 1; espacio = 0; cad = ""; while(!inout.eof()){//inicio while inout.getline(linea,120);//obtiene la linea del archivo cad_temp=AnsiString(linea);//asigna la linea a una cadena if(cad_temp=="#INCLUIR otras_reglas"){ reglas.open("otras_reglas.dat"); while(!reglas.eof()){ reglas.getline(linea,120);//obtiene la linea del archivo cad=AnsiString(linea);//asigna la linea a una cadena


115

size=int(cad.Length());//obtiene la longitud de la cadena if((cad==' ')||(size==0)){n=1;} for(int i=0;i<=size;i++){//inicio for for(int l=0;l<=size;l++){ if(cad.c_str()[l]=='.')c=1; } if((cad.c_str()[i]!='\0')&&(cad.c_str()[i]!=',')&&(cad.c_str()[i]!='-') &&(cad.c_str()[i]!=';')&& (cad.c_str()[i]!='.')&&(cad.c_str()[i]!='(')&& (cad.c_str()[i]!=')')){//inicio if temporal[j]=cad.c_str()[i];//Asigna una palabra a un arreglo temporal if(columna == 1 ){ //solo para eliminar los espacios en la primer columna if(temporal[j]!=' ') j++; }else{ j++; } if(j > tamC){tamC = j;} espacio=0; }//end_if else{//inicio else espacio++; if(espacio <=1 ){//inicio if StringGrid2->Cells[columna][linea_fin]=temporal;//vacia la cadena al StringGrid for(int i=0;i<j;i++)//inicio for temporal[i]=' '; columna++; if(columna > numC){numC=columna;} if(columna > col){//inicio if StringGrid2->ColCount=columna;//asigna la columna max. col=columna; }//fin if j=0; }//fin for }//fin de if if(((cad.c_str()[i]==')')&&(cad.c_str()[i+1]==','))||((c==1) && (cad.c_str()[i]==','))) {columna=2;linea_fin++;} }//fin else columna=1; j=0; c=0; if(n==1){ linea_fin=linea_fin; }else{ linea_fin++;//Incrementa la linea } StringGrid2->RowCount=linea_fin; }//while }// }//fin del while reglas.close(); StringGrid2->RowCount=linea_fin; Ordena_String(); Ordena_String_renglon(); for(int i=1;i <= StringGrid2->RowCount;i++){ StringGrid2->Cells[0][i]=i; StringGrid2->ColWidths[0]=20; } for(int i=3;i <StringGrid2->ColCount;i++) StringGrid2->Cells[i][0]="VALORES"; StringGrid2->Cells[1][0]="CONSECUENTE"; StringGrid2->Cells[2][0]="ANTECEDENTE"; reordenar(Form1->StringGrid2); verifica_duplicidad(Form1->StringGrid2); } //---------------------------------------------------------------------------

Compilación de las reglas simbólicas //Compilacin1Click: //Se encarga de iniciar con la compilación de reglas a una red neuronal void __fastcall TForm1::Compilacin1Click(TObject *Sender) { //Comienza la primer parte del algoritmo, donde se reetiquetan los consecuentes reescribir(Form1->StringGrid2); //NoConsecutivo = 0; /*A continuación se crean todas las unidades de la red neuronal de acuerdo a su tipo y al conjunto de valores que forman cada una de los atributos, para ello se tiene una función para cada tipo de atributo, por lo que se da como paráme tro tanto el nombre del atributo como su tipo, para ser posteriormente alma cenado en un vector llamado <entrada_tipo> */ red obj; for(int i=1;i < StringGrid1->RowCount;i++){ obj.nombre=StringGrid1->Cells[1][i]; obj.tipo=StringGrid1->Cells[2][i]; if(obj.tipo=="BINARIO"){ obj.Unidades_Entrada_Binarias(obj.nombre ); } if(obj.tipo=="NOMINAL"){ obj.Unidades_Entrada_Nominales(obj.nombre,i); } if(obj.tipo=="RANGO"){ obj.Unidades_Entrada_Rango(obj.nombre); } if(obj.tipo=="CONTINUO"){ obj.Unidades_Entrada_Continuo(obj.nombre,i); } if(obj.tipo=="ORDENADO"){ obj.Unidades_Entrada_Ordenadas(obj.nombre,i); } } /*En la siguiente parte se procede a la compilación de las reglas, por lo que se requiere analizar cada consecuente con sus antecedentes, para ello se re quiere llamar a las funciones:Verifica_Neurona_Antecedent(),Verificación_de_ antecedentes(),Verifica_Regla(),y Bias_Funcio_Cons()*/ NoConse_Consecuente = 0; Nu_Antecedente = 0; red Llamada_funcion; AnsiString Nomb_Cons = ""; AnsiString funcion = ""; AnsiString tmral = ""; int size = 0; int sizeAnt = 0; int size_tmral = 0; Func_Ant LLamar; int n; char B; positivo=0;


116

compilacion_red llamar_funcion; for(int i=1;i < StringGrid2->RowCount;i++){ Nomb_Cons=StringGrid2->Cells[1][i]; size=int(Nomb_Cons.Length()); if((Nomb_Cons.c_str()[0]!=' ')&& (size !=0)){ n=Llamada_funcion.Verifica_Neurona_Antecedente(Nomb_Cons); LLamar.Etiqueta(Nomb_Cons,n); for(int j=i; j < StringGrid2->RowCount;j++){ funcion=StringGrid2->Cells[2][j]; sizeAnt=int(funcion.Length()); if((funcion.c_str()[0]!=' ')&& (sizeAnt !=0)) { LLamar.Verificacion_de_antecedentes(funcion,j,n);//Verifica al antecedente } tmral= StringGrid2->Cells[1][j+1]; size_tmral=int(tmral.Length()); if(size_tmral==0){ } else { break; } } B=Verifica_Regla(i); llamar_funcion.Bias_Funcio_Cons(n,B); positivo=0; } } Llamada_funcion.Imprime_Etiquetas();//Llamada a la función para incluir las etiquetas de las neuronas ShowMessage("Fin de la compilación"); } //--------------------------------------------------------------------------- //Acercade1Click: //Se encarga de visualizar los datos personales del sistema void __fastcall TForm1::Acercade1Click(TObject *Sender) { //Cuadro de diálogo para los datos del Acerca de.. TForm3 *Form3; Form3 = new TForm3(this); Form3->ShowModal(); } //--------------------------------------------------------------------------- //Parmetrosdelacompilacin1Click: //Llama a la forma de Parámetros de Compilación void __fastcall TForm1::Parmetrosdelacompilacin1Click(TObject *Sender) { TForm4 *Form4; Form4 = new TForm4(this); Form4->ShowModal(); }

//--------------------------------------------------------------------------- //wtsytop1Click: //Llama a la forma donde se podrán visualizar e imprimir los archivos *.wts y *.top void __fastcall TForm1::wtsytop1Click(TObject *Sender) { TForm5 *Form5; Form5=new TForm5(this); Form5->ShowModal(); } //--------------------------------------------------------------------------- void __fastcall TForm1::Timer1Timer(TObject *Sender) { TDateTime DateTime = Time(); // store the current date and time AnsiString str = TimeToStr(DateTime); // convert the time to a string StatusBar1->Panels->Items[0]->Text=str; StatusBar1->Panels->Items[1]->Text=OpenDialog1->FileName; } //--------------------------------------------------------------------------- void __fastcall TForm1::CSpinEdit1Change(TObject *Sender) { Memo1->Font->Size=CSpinEdit1->Value; } //--------------------------------------------------------------------------- void __fastcall TForm1::Button1Click(TObject *Sender) { if(Button1->Font->Style != TFontStyles() << fsBold ){ Memo1->Font->Style = TFontStyles()<< fsBold ; Button1->Font->Style= TFontStyles() << fsBold; } else{ Memo1->Font->Style = TFontStyles(); Button1->Font->Style= TFontStyles(); } } //--------------------------------------------------------------------------- //Resumen1Click //Llama a la función que se encargará de obtener el archivo del resumen void __fastcall TForm1::Resumen1Click(TObject *Sender) { Func_Ant llama_funcion; llama_funcion.Archivo_Resumen(); } //--------------------------------------------------------------------------- //----------------------------------------------

----------------------------- //--------------------------------------------------------------------------- #include <vcl.h> #include <String.h> #include <fstream.h> #include <stdlib.h>


117

#include <conio.h> #include <stdio.h> #include <vector.h> #include "red.hpp" #include "SHNS.h" #pragma hdrstop //--------------------------------------------------------------------------- int unidad=0; red obj1,obj2; int red::Regresa_Num_NE(){ obj1.nivel=1; return(obj2.Unidades_Entrada); } //Función que obtiene el nombre y la cantidad de las neuronas de tipo binarias void red::Unidades_Entrada_Binarias(AnsiString nombre_atrib_binary){ AnsiString nombre_binario; AnsiString Tipo_neurona; Tipo_neurona="BINARIO"; nombre_binario=nombre_atrib_binary;//Pase del nombre de tipo binario unidad=1; obj2.Unidades_Entrada+=unidad;//num. de unidades a crear obj2.Almacena_Neuronas(nombre_binario,Tipo_neurona); unidad=0; } //Función que obtiene el nombre y la cantidad de las neuronas de tipo nominales void red::Unidades_Entrada_Nominales(AnsiString nombre_atrib_nominal, int j){ AnsiString Tipo_neurona; Tipo_neurona="NOMINAL"; AnsiString Valor_nominal; for(int i=3;i < Form1->StringGrid1->ColCount;i++){ Valor_nominal=Form1->StringGrid1->Cells[i][j]; int size=int(Valor_nominal.Length()); if(Valor_nominal!=' ' && size!=0){ unidad=1; obj2.Unidades_Entrada+=unidad; obj2.Almacena_Neuronas(nombre_atrib_nominal, Valor_nominal,Tipo_neurona); } } unidad=0; } //Función que obtiene el nombre y la cantidad de las neuronas de tipo rango void red::Unidades_Entrada_Rango(AnsiString nombre_atrib_rango){ AnsiString Tipo_neurona; Tipo_neurona="RANGO"; AnsiString Neurona_rango; Neurona_rango=nombre_atrib_rango; unidad=1; obj2.Unidades_Entrada+=unidad; obj2.Almacena_Neuronas(Neurona_rango, Tipo_neurona); unidad=0; } //Función que obtiene el nombre y la cantidad de las neuronas de tipo continuas void red::Unidades_Entrada_Continuo(AnsiString nombre_atrib_continuo,int j){ AnsiString Tipo_neurona; Tipo_neurona="CONTINUO"; AnsiString Neurona_continuo;

for(int i=3;i < Form1->StringGrid1->ColCount;i=i+3){ Neurona_continuo=Form1->StringGrid1->Cells[i][j]; int size=int(Neurona_continuo.Length()); if(Neurona_continuo!=' '&& size!=0){ unidad=1; obj2.Unidades_Entrada+=unidad; obj2.Almacena_Neuronas(nombre_atrib_continuo,Neurona_continuo,Tipo_neurona); } } unidad=0; } //Función que obtiene el nombre y la cantidad de las neuronas de tipo ordenadas void red::Unidades_Entrada_Ordenadas(AnsiString nombre_atrib_ordenado, int j){ AnsiString Tipo_neurona; Tipo_neurona="ORDENADAS"; AnsiString Valor_ordenada; for(int i=3;i < Form1->StringGrid1->ColCount;i++){ Valor_ordenada=Form1->StringGrid1->Cells[i][j]; int size=int(Valor_ordenada.Length()); if(Valor_ordenada!=' '&& size!=0){ unidad=1; obj2.Unidades_Entrada+=unidad; obj2.Almacena_Neuronas(nombre_atrib_ordenado, Valor_ordenada,Tipo_neurona); } } unidad=0; } //--------------------------------------------------------------------------- //--------------------------------------------------------------------------- #include <vcl.h> #include <String.h> #include <fstream.h> #include <stdlib.h> #include <conio.h> #include <stdio.h> #include <vector.h> #include "red.hpp" #include "SHNS.h" #include "Func_Ant.hpp" #include "Unit4.h" #include "compilacion_red.hpp" #pragma hdrstop Topología compilacion_red llamada; //Parámetro para ser llamada una función vector<red> Numero(0); //Vector que almacena el numero de c/u de las neuronas vector<red> inputs(0); //Almacena las entradas vector<red> etiquetas_antecedente(0); //Almacena las unidades antecedentes vector<red> etiquetas_consecuente(0); //Almacena las unidades consecuentes vector<red> Temp_Ligas(0); //Almacena las ligas temporalmente para el primer proceso vector<red> Temp_Ligas_(0); //Almacena las ligas temporalmente para el segundo proceso vector<red> Ligas(0); //Almacena las ligas temporalmente para el tercer proceso vector<red> Almacen_Ligas(0);//Almacena las ligas temporalmente para el tercer proceso vector<red> Salidas(0); //Almacena las unidades de salida //Los siguiente son objetos creados a partir de una clase para manipular la información red salida;


118

red objetos; red llamada_Num_Entradas; red inps; red Num; red label1; red label2; red L,AL; red llamar_func_AtributoAd; Func_Ant obj; int Num_capas; //Obtiene el numero de capas /*Link: Función que guarda la topología de la red neuronal artificial en los vectores antecedente y consecuente y verifica que no existan ligas repetidas, toma como parametros el nombre de la etiqueta, el numero de antecedente y el numero de consecuente. */ void Func_Ant::Link(char Etiqueta,int Nu_Antecedente,int Num_Cons){ label2.Link_etiqueta=Etiqueta; label2.Link_ant=Nu_Antecedente; label1.Link_cnt=Num_Cons; //Antes de ser guardados debe ser verificado que no exista una liga repetida a guardar int tam1=etiquetas_antecedente.size(); if(tam1==0){ etiquetas_antecedente.push_back(label2); etiquetas_consecuente.push_back(label1); } else{ for(int i=0;i < tam1;i++){ if((label2.Link_ant==etiquetas_antecedente[i].Link_ant)&&(label2.Link_etiqueta==etiquetas_antecedente[i].Link_etiqueta) &&(label1.Link_cnt==etiquetas_consecuente[i].Link_cnt)) goto fin1; } etiquetas_antecedente.push_back(label2); etiquetas_consecuente.push_back(label1); } fin1: } //Asigna_Etiqueta: (función llamada desde imprime etiquetas) /*Imprime las etiquetas I,N u O dependiendo del tipo de neurona actualizando las ligas ademas, relaciona los atributos adicionales con las salidas, estableciendose la rela ción de estas en la red, mediante la función Atributo_Adicionales()*/ void Asigna_Etiqueta(){ char T='F'; char R='F'; int i; int j; //Se obtiene el tamaño actual del vector para ser utilizado en el etiquetado //de las unidades int tamano_link_A=etiquetas_antecedente.size(); int tamano_link_C=etiquetas_consecuente.size(); for(j=0;j < tamano_link_C;j++){ for(i=0;i < tamano_link_A;i++){ if((etiquetas_consecuente[j].Link_cnt==etiquetas_antecedente[i].Link_ant)&&(etiquetas_antecedente[i].Link_etiqueta!='I')) T='V'; }

if(T=='V'){ etiquetas_antecedente[j].Link_etiqueta=etiquetas_antecedente[j].Link_etiqueta; } else{ //Verifica que el consecuente sea una unidad oculta o una unidad de salida char N; etiquetas_antecedente[j].Link_etiqueta=etiquetas_antecedente[j].Link_etiqueta; N='O'; for(int i=0; i < tamano_link_A;i ++){ if((etiquetas_consecuente[j].Link_cnt==etiquetas_antecedente[i].Link_ant)&&(etiquetas_antecedente[i].Link_etiqueta!='N')&&(etiquetas_antecedente[i].Link_etiqueta!='I')) R='V'; } //Si R==F quiere decir que esa unidad es de salida y que debe ser creada y // etiquetada como salida if(R=='F'){ obj.Link(N,etiquetas_consecuente[j].Link_cnt,etiquetas_consecuente[j].Link_cnt); llamar_func_AtributoAd.Atributo_Adicionales(Form1->Num_Renglon_Atributos_Adicionales,'I',etiquetas_consecuente[j].Link_cnt); salida.Num=etiquetas_consecuente[j].Link_cnt; Salidas.push_back(salida); Form1->num_neuronas_salida++; } R='F'; } T='F'; //Se actualiza el tamaño de los vectores debido a su posible incremento. tamano_link_A=etiquetas_antecedente.size(); tamano_link_C=etiquetas_consecuente.size(); } } //Capas(): //Calcula el numero de capas verificando cual es el camino mas largo a una unidad //de entrada, regresando el numero de capas con Total_Capas. int Capas(){ int N_Capas=0; int Total_Capas=0; int C;//Guarda el consecuente int size=Temp_Ligas.size(); for(int i=0;i < size;i++){ if(Temp_Ligas[i].Link_etiqueta=='N'){ C=Temp_Ligas[i].nx; N_Capas++; char T='F'; for(int j=0;j < size;){ if((Temp_Ligas[j].Link_etiqueta=='N'||Temp_Ligas[j].Link_etiqueta=='O' )&& C==Temp_Ligas[j].ni){ C=Temp_Ligas[j].nx; N_Capas++;//incrementa el numero de capas T='V'; } if(T=='V'&&(Temp_Ligas[j].nx!=Temp_Ligas[j].ni)){j=0;T='F';}else j++;


119

} if(N_Capas > Total_Capas){ Total_Capas=N_Capas; } N_Capas=0; } } return(Total_Capas); } //Lincks_Desde_Hasta:(esta función es llamada desde imprime_etiquetas()) /*Se encarga de crear las relaciones que existen de una neurona a otra de tal forma que si la unidad 0 y 1 se relacionan ambas con la 2 y 3, se traduciría asi: 0 1 2 3, o si la 0 y 1 se relacionan solo con la 3, se traducirìa como: 0 1 3 3*/ void Links_Desde_Hasta(){ //Primer tabla que guarda en Temp_Ligas la etiqueta, el antecedente y el //consecuente int tamano_link_A=etiquetas_antecedente.size(); for(int i=0;i < tamano_link_A;i++){ if(etiquetas_antecedente[i].Link_etiqueta=='I'){ L.Link_etiqueta=etiquetas_antecedente[i].Link_etiqueta; L.ex=etiquetas_antecedente[i].Link_ant; L.ey=0; L.nx=etiquetas_consecuente[i].Link_cnt; L.ny=0; Temp_Ligas.push_back(L); } else{ L.Link_etiqueta=etiquetas_antecedente[i].Link_etiqueta; L.ni=etiquetas_antecedente[i].Link_ant; L.nj=0; L.nx=etiquetas_consecuente[i].Link_cnt; L.ny=0; Temp_Ligas.push_back(L); } } Num_capas=Capas(); //Segunda tabla que guarda la relacion de los antecedentes conectados a un //mismo consecuente int tam_Ligas=Temp_Ligas.size(); for(int j=0;j < tam_Ligas;j++){ char V='F'; //relaciona las unidades desde ex hasta ey conectada a la misma nx if(Temp_Ligas[j].Link_etiqueta=='I'){ int Tex=Temp_Ligas[j].ex; int Tnx=Temp_Ligas[j].nx; char V='F'; char T='F'; for(int i=0;i < tam_Ligas;){ if((Temp_Ligas[i].Link_etiqueta=='I' && Temp_Ligas[i].ex==Tex+1) &&(Temp_Ligas[i].nx==Tnx )){ L.Link_etiqueta=Temp_Ligas[j].Link_etiqueta; L.ex=Temp_Ligas[j].ex; L.ey=Temp_Ligas[i].ex; L.nx=Temp_Ligas[j].nx; L.ny=0; Temp_Ligas.erase(&Temp_Ligas[i]); Tex=Tex+1; V='T'; T='V';

} if(T=='V'){i=i;T='F';}else{ i++;} tam_Ligas=Temp_Ligas.size(); } if(V=='F'){ L.Link_etiqueta=Temp_Ligas[j].Link_etiqueta; L.ex=Temp_Ligas[j].ex; L.ey=Temp_Ligas[j].ex; L.nx=Temp_Ligas[j].nx; L.ny=0; } V='F'; Temp_Ligas_.push_back(L); } //relaciona las unidades desde ni hasta nj conectada a la misma nx if(Temp_Ligas[j].Link_etiqueta=='N'){ int Tni=Temp_Ligas[j].ni; int Tnx=Temp_Ligas[j].nx; char V='F'; char T='F'; for(int i=0;i < tam_Ligas;){ if((Temp_Ligas[i].Link_etiqueta=='N' && Temp_Ligas[i].ni==Tni+1) &&(Temp_Ligas[i].nx==Tnx )){ L.Link_etiqueta=Temp_Ligas[j].Link_etiqueta; L.ni=Temp_Ligas[j].ni; L.nj=Temp_Ligas[i].ni; L.nx=Temp_Ligas[j].nx; L.ny=0; Temp_Ligas.erase(&Temp_Ligas[i]); Tni=Tni+1; V='T'; T='V'; } if(T=='V'){i=i;T='F';}else{ i++;} tam_Ligas=Temp_Ligas.size(); } if(V=='F'){ L.Link_etiqueta=Temp_Ligas[j].Link_etiqueta; L.ni=Temp_Ligas[j].ni; L.nj=Temp_Ligas[j].ni; L.nx=Temp_Ligas[j].nx; L.ny=0; } V='F'; Temp_Ligas_.push_back(L); } //relaciona las unidades desde nx hasta ny if(Temp_Ligas[j].Link_etiqueta=='O'){ L.Link_etiqueta=Temp_Ligas[j].Link_etiqueta; L.nx=Temp_Ligas[j].nx; L.ny=Temp_Ligas[j].nx; Temp_Ligas_.push_back(L); } tam_Ligas=Temp_Ligas.size(); } //tercer Tabla y ultima que guarda las relaciones existentes entre ex hasta ey //conectadas desde nx a ny int S=Temp_Ligas_.size(); for(int j=0;j < S;j++){ char V='F'; char T='F'; //relaciona las unidades desde ex hasta ey conectada desde nx a ny if(Temp_Ligas_[j].Link_etiqueta=='I'){ int Tex=Temp_Ligas_[j].ex;


120

int Tey=Temp_Ligas_[j].ey; int Tnx=Temp_Ligas_[j].nx; for(int i=0;i < S;){ if((Temp_Ligas_[i].Link_etiqueta=='I' )&& (Temp_Ligas_[i].ex==Tex && Temp_Ligas_[i].ey==Tey)&&(Temp_Ligas_[i].nx==Tnx+1)){ L.Link_etiqueta=Temp_Ligas_[j].Link_etiqueta; L.ex=Temp_Ligas_[j].ex; L.ey=Temp_Ligas_[j].ey; L.nx=Temp_Ligas_[j].nx; L.ny=Temp_Ligas_[i].nx; Temp_Ligas_.erase(&Temp_Ligas_[i]); Tnx=Tnx+1; T='V'; V='T'; } if(T=='V'){i=i;T='F';}else{ i++;} S=Temp_Ligas_.size(); } if(V=='F'){ L.Link_etiqueta=Temp_Ligas_[j].Link_etiqueta; L.ex=Temp_Ligas_[j].ex; L.ey=Temp_Ligas_[j].ey; L.nx=Temp_Ligas_[j].nx; L.ny=Temp_Ligas_[j].nx; } Ligas.push_back(L); V='F'; AL.Link_etiqueta=L.Link_etiqueta; AL.v1=L.ex; AL.v2=L.ey; AL.v3=L.nx; AL.v4=L.ny; Almacen_Ligas.push_back(AL); } //relaciona las unidades desde ni hasta nj conectada desde nx a ny if(Temp_Ligas_[j].Link_etiqueta=='N'){ int Tni=Temp_Ligas_[j].ni; int Tnj=Temp_Ligas_[j].nj; int Tnx=Temp_Ligas_[j].nx; char V='F'; for(int i=0;i < S;){ if((Temp_Ligas_[i].ni==Tni && Temp_Ligas_[i].nj==Tnj)&&(Temp_Ligas_[i].nx==Tnx+1)){ L.Link_etiqueta=Temp_Ligas_[j].Link_etiqueta; L.ni=Temp_Ligas_[j].ni; L.nj=Temp_Ligas_[j].nj; L.nx=Temp_Ligas_[j].nx; L.ny=Temp_Ligas_[i].nx; Temp_Ligas_.erase(&Temp_Ligas_[i]); Tnx=Tnx+1; T='V'; V='T'; } if(T=='V'){i=i;T='F';}else{ i++;} S=Temp_Ligas_.size(); } if(V=='F'){ L.Link_etiqueta=Temp_Ligas_[j].Link_etiqueta; L.ni=Temp_Ligas_[j].ni; L.nj=Temp_Ligas_[j].nj; L.nx=Temp_Ligas_[j].nx; L.ny=Temp_Ligas_[j].nx; } V='F'; Ligas.push_back(L); AL.Link_etiqueta=L.Link_etiqueta; AL.v1=L.ni; AL.v2=L.nj; AL.v3=L.nx; AL.v4=L.ny; Almacen_Ligas.push_back(AL); }

//relaciona las unidades conectadas desde nx a ny if(Temp_Ligas_[j].Link_etiqueta=='O'){ L.Link_etiqueta=Temp_Ligas_[j].Link_etiqueta; L.nx=Temp_Ligas_[j].nx; L.ny=Temp_Ligas_[j].nx; Ligas.push_back(L); AL.Link_etiqueta=L.Link_etiqueta; AL.v1=L.nx; AL.v2=L.ny; AL.v3=L.nx; AL.v4=L.ny; Almacen_Ligas.push_back(AL); } S=Temp_Ligas_.size(); } } //Etiqueta:(las neuronas ocultas y de salida) //Guarda el numero de neurona y nombre, en el vector Numero para ser //posteriormente imprimida en el archivo de topología void Func_Ant::Etiqueta(AnsiString Nomb_Neurona, int Num_Neurona){ Num.Num=Num_Neurona; Num.nombre=Nomb_Neurona; Num.tipo=""; int tamano=Numero.size(); if(tamano==0){ Numero.push_back(Num); Form1->num_neuronas_ocultas++; } else{ for(int i=0;i < tamano;i++){ if(Num.Num==Numero[i].Num) goto fin; } Numero.push_back(Num); Form1->num_neuronas_ocultas++; } fin: } //Etiqueta:(las neuronas ocultas y de salida) //Guarda el nombre de funcion, Nombre de neurona,y Numero en Numero para ser //posteriormente imprimida en el archivo de topologia void Func_Ant::Etiqueta(AnsiString Nomb_funcion,AnsiString Nomb_Neurona, int Num_Neurona){ Num.Num=Num_Neurona; Num.tipo=Nomb_funcion; Num.nombre=Nomb_Neurona; int tamano=Numero.size(); if(tamano==0){ Numero.push_back(Num); Form1->num_neuronas_ocultas++; } else{ for(int i=0;i < tamano;i++){ if(Num.Num==Numero[i].Num) goto fin; } Numero.push_back(Num); Form1->num_neuronas_ocultas++; } fin: } //Etiqueta_Entradas: (las neuronas de entrada) //Guarda el nombre y el numero de la neurona de entrada en el vector inputs para //ser posteriormente imprimidas en el archivo de topología. void red::Etiqueta_Entradas(AnsiString Nomb_Neurona, int k){ inps.nombre=Nomb_Neurona; inps.Num=k;


121

int tamano=inputs.size(); if(tamano==0){ inputs.push_back(inps); } else{ for(int i=0;i < tamano;i++){ if(inps.Num==inputs[i].Num) goto fin; } inputs.push_back(inps); } fin: } //Imprime_etiquetas: //Una vez guardadas las etiquetas se procede a imprimirlas en archivo de topologia //Aqui se llama a las funciones asigna_etiqueta() y Links_Desde_Hasta(). void red::Imprime_Etiquetas(){ Asigna_Etiqueta(); Links_Desde_Hasta(); Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red <<"% "<<endl; Form1->Archivo_Red <<"% ANN creada automáticamente por CompSimb "<<endl; Form1->Archivo_Red <<"% "<<endl; Form1->Archivo_Red <<"$Network"<<endl; Form1->Archivo_Red << llamada_Num_Entradas.Regresa_Num_NE() << " " <<Form1->num_neuronas_salida <<" " <<Num_capas<<" "<<Form1->num_neuronas_ocultas <<" " << endl; Form1->Archivo_Red <<"$Connections"<<endl; Form1->Archivo_Red.close(); //Imprime las etiquetas I,N u O dependiendo del tipo de neurona asi como los links int i; int j; int tamano_Link=Almacen_Ligas.size(); for(j=0;j < tamano_Link;j++){ if(Almacen_Ligas[j].Link_etiqueta=='O'){ Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red << Almacen_Ligas[j].Link_etiqueta <<" "<<Almacen_Ligas[j].v1<<" "<<Almacen_Ligas[j].v2 <<endl; Form1->Archivo_Red.close(); } else{ Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red << Almacen_Ligas[j].Link_etiqueta <<" "<<Almacen_Ligas[j].v1<<" "<<Almacen_Ligas[j].v2 <<" "<<Almacen_Ligas[j].v3<<" "<<Almacen_Ligas[j].v4 <<endl; Form1->Archivo_Red.close(); } } //Imprime las neuronas ocultas int tamano=Numero.size(); Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red << "$Labels" << endl; for(int i=0; i< tamano;i++){ Form1->Archivo_Red << Numero[i].Num <<" "<< Numero[i].tipo.c_str() <<"_"<<Numero[i].nombre.c_str()<<" "<< endl; } Form1->Archivo_Red.close(); //Imprime las neuronas de entrada int tamno=inputs.size(); Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red << "$Inputs" << endl;

for(int i=0; i< tamno;i++){ Form1->Archivo_Red << inputs[i].Num <<" "<< inputs[i].nombre.c_str()<<" "<< endl; } Form1->Archivo_Red.close(); //Agrega al archivo de pesos la información de la red Form1->Archivo_Red_wts.open(Form1->Nombre_wts.c_str(),ios::in|ios::out); Form1->Archivo_Red_wts << llamada_Num_Entradas.Regresa_Num_NE() << " " <<Form1->num_neuronas_salida <<" " <<Num_capas<<" "<<Form1->num_neuronas_ocultas << " "<<"Compiled" << endl; Form1->Archivo_Red_wts.close(); Form1->Archivo_Red_wts.open(Form1->Nombre_wts.c_str(),ios::app); Form1->Archivo_Red_wts <<"End"<< endl; Form1->Archivo_Red_wts.close(); } //Verificación_de_antecedentes: //Función que verifica cual será la unidad a crear de acuerdo a la funcion_antecedente //recibe como parámetros el nombre de la función, el numero de renglon a analizar en el //StringGrid2 y el número de consecuente al cual se va a ligar el antecedente. void Func_Ant::Verificacion_de_antecedentes(AnsiString funcion,int n,int Num_Cons){ char Label; int Bandera=0; int N=0; red ObjAnt,llamada_ImpE; if(funcion=="EN_RANGO"){ Bandera=1; int atributo; int GT,LT; //Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Nomb=Form1->StringGrid2->Cells[3][n]; float Val1=atof(Form1->StringGrid2->Cells[4][n].c_str()); float Val2=atof(Form1->StringGrid2->Cells[5][n].c_str()); atributo=ObjAnt.Verifica_Neurona(Nomb); Label='I'; llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); //Para crear la unidad mayor que GT=ObjAnt.Verifica_Neurona_Antecedente("MAYOR_QUE", Nomb); Link(Label,atributo,GT); Etiqueta("GT",Nomb,GT); //Para crear la unidad menor que LT=ObjAnt.Verifica_Neurona_Antecedente("MENOR_QUE", Nomb); Link(Label,atributo,LT); Etiqueta("LT",Nomb,LT); //Crea la unidad correspondiente a la función En Rango como antecedente N=ObjAnt.Verifica_Neurona_Antecedente("IN_RANGE", Nomb); Label='N'; //Se crean los links correspondientes a una funcion rango Link(Label,GT,N); Link(Label,LT,N); Link(Label,N,Num_Cons); Etiqueta("IN_RANGE",Nomb,N); //Se colocan los pesos de acuerdo a su funcion llamada.Funcio_MAQ('I',atributo,GT,Val1); llamada.Funcio_MEQ('I',atributo,LT,Val2);


122

llamada.Funcio_ER(Label,GT,LT,N); llamada.Funcio_Ent(Label,N,Num_Cons); Form1->positivo++; } if(funcion=="IGUAL"){ Bandera=1; int atributo; int B=0; int GT,LT; //Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Igual_A=Form1->StringGrid2->Cells[4][n]; AnsiString Nomb=Form1->StringGrid2->Cells[3][n]; B=ObjAnt.Verifica_SegundoValor_Neurona(Igual_A); if(B!=1){ float ValsCte= atof(Igual_A.c_str()); atributo=ObjAnt.Verifica_Neurona(Nomb); Label='I'; llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); //Crea la unidad correspondiente a una función como antecedente para crear la unidad mayor que GT=ObjAnt.Verifica_Neurona_Antecedente("GT", Nomb); Link(Label,atributo,GT); Etiqueta("GT",Nomb,GT); //Para crear la unidad menor que LT=ObjAnt.Verifica_Neurona_Antecedente("LT", Nomb); Link(Label,atributo,LT); Etiqueta("LT",Nomb,LT); //Crea la unidad correspondiente a la función En Rango como antecedente N=ObjAnt.Verifica_Neurona_Antecedente("EQUAL", Nomb); Label='N'; Link(Label,GT,N); Link(Label,LT,N); Link(Label,N,Num_Cons); Etiqueta("EQUAL",Nomb,N); //Se colocan los pesos de acuerdo a su funcion llamada.Funcio_MAQ('I',atributo,GT,ValsCte); llamada.Funcio_MEQ('I',atributo,LT,ValsCte); llamada.Funcio_IGUAL(Label,GT,LT,N); } else{ int segundo_valor; atributo=ObjAnt.Verifica_Neurona(Nomb);//Obtiene el num. de neurona de entrada Label='I'; llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); AnsiString Cadena_Funcion= AnsiString(Nomb)+ AnsiString(Igual_A); //Crea la unidad correspondiente a una función como antecedente //Para crear la unidad mayor que GT=ObjAnt.Verifica_Neurona_Antecedente("GT",Cadena_Funcion); LT=ObjAnt.Verifica_Neurona_Antecedente("LT", Cadena_Funcion); segundo_valor=ObjAnt.Verifica_Segundo_Valor_EnRed(Igual_A);//llamada para verificar cuantos valores tiene N=ObjAnt.Verifica_Neurona_Antecedente("EQUAL",

Cadena_Funcion);//Verifica la existencia de esta funcion Etiqueta("GT",Cadena_Funcion,GT); Etiqueta("LT",Cadena_Funcion,LT); llamada_ImpE.Etiqueta_Entradas(Igual_A,segundo_valor); Link(Label,atributo,GT); Link(Label,atributo,LT); Link(Label,segundo_valor,GT); Link(Label,segundo_valor,LT); Label='N'; Link(Label,GT,N); Link(Label,LT,N); Link(Label,N,Num_Cons); Etiqueta("EQUAL",Cadena_Funcion,N); llamada.Funcio_MAQ('I',atributo,segundo_valor,GT); llamada.Funcio_MEQ('I',atributo,segundo_valor,LT); llamada.Funcio_IGUAL(Label,GT,LT,N);//Obtiene el peso correspondiente a esta función } llamada.Funcio_Ent(Label,N,Num_Cons); Form1->positivo++; } if(funcion=="NO"){ Bandera=1; int atributo; int B=0; //Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Nomb=Form1->StringGrid2->Cells[3][n]; AnsiString Valor=Form1->StringGrid2->Cells[4][n]; B=ObjAnt.Verifica_SegundoValor_Neurona(Nomb); if(B==1){ Label='I'; //Crea la unidad correspondiente a un antecedente N=ObjAnt.Verifica_Neurona_Antecedente("NOT", Nomb); ObjAnt.Verifica_Tipo_Atributo(Label,N,Nomb,Valor);//llamada para verificar cuantos valores tiene Label='N'; Link(Label,N,Num_Cons); Etiqueta("NOT",Nomb,N); llamada.Funcio_Not('I',Form1->atributo_activo,N); } else{ B=ObjAnt.Verifica_Neurona_En_consecuente(Nomb); Label='N'; N=ObjAnt.Verifica_Neurona_Antecedente("NOT", Nomb); Link(Label,B,N); Link(Label,N,Num_Cons); Etiqueta(Nomb,B); Etiqueta("NOT",Nomb,N); llamada.Funcio_Not(Label,B,N); } llamada.Funcio_Ent(Label,N,Num_Cons); } if(funcion=="MAYOI"){ Bandera=1; int atributo; int B=0;


123

//Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Nomb=Form1->StringGrid2->Cells[3][n]; AnsiString Valor=Form1->StringGrid2->Cells[4][n]; B=ObjAnt.Verifica_SegundoValor_Neurona(Valor); if(B!=1){ float ValsCte= atof(Valor.c_str()); Label='I'; //Crea la unidad correspondiente a un antecedente N=ObjAnt.Verifica_Neurona_Antecedente("GTOE", Nomb); ObjAnt.Verifica_Tipo_Atributo(Label,N,Nomb,Valor);//llamada para verificar cuantos valores tiene Label='N'; Link(Label,N,Num_Cons); Etiqueta("GTOE",Nomb,N); llamada.Funcio_MoIQ('I',Form1->atributo_activo,N,ValsCte); } else{ int segundo_valor; atributo=ObjAnt.Verifica_Neurona(Nomb);//Obtiene el num. de neurona de entrada Label='I'; AnsiString Cadena_Funcion= AnsiString(Nomb)+ AnsiString(Valor); N=ObjAnt.Verifica_Neurona_Antecedente("GTOE", Cadena_Funcion);//Verifica la existencia de esta funcion Link(Label,atributo,N); llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); segundo_valor=ObjAnt.Verifica_Segundo_Valor_EnRed(Valor);//llamada para verificar cuantos valores tiene llamada.Funcio_MoIQ(Label,atributo,segundo_valor,N);//Obtiene el peso correspondiente a esta función Link(Label,segundo_valor,N); llamada_ImpE.Etiqueta_Entradas(Valor,segundo_valor); Label='N'; Link(Label,N,Num_Cons); Etiqueta("GTOE",Cadena_Funcion,N); } llamada.Funcio_Ent(Label,N,Num_Cons); Form1->positivo++; } if(funcion=="MENOI"){ Bandera=1; int atributo; int B=0; //Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Valor=Form1->StringGrid2->Cells[4][n]; AnsiString Nomb=Form1->StringGrid2->Cells[3][n];//Obtiene el nombre del atributo B=ObjAnt.Verifica_SegundoValor_Neurona(Valor); if(B!=1){ float ValsCte= atof(Valor.c_str()); Label='I'; N=ObjAnt.Verifica_Neurona_Antecedente("LTOE", Nomb);//Verifica la existencia de esta funcion ObjAnt.Verifica_Tipo_Atributo(Label,N,Nomb,Valor);//llamada para verificar cuantos valores tiene Label='N';

Link(Label,N,Num_Cons); Etiqueta("LTOE",Nomb,N); llamada.Funcio_MEoIQ('I',Form1->atributo_activo,N,ValsCte); } else{ int segundo_valor; atributo=ObjAnt.Verifica_Neurona(Nomb);//Obtiene el num. de neurona de entrada Label='I'; AnsiString Cadena_Funcion= AnsiString(Nomb)+ AnsiString(Valor); N=ObjAnt.Verifica_Neurona_Antecedente("LTOE", Cadena_Funcion);//Verifica la existencia de esta funcion Link(Label,atributo,N); llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); segundo_valor=ObjAnt.Verifica_Segundo_Valor_EnRed(Valor);//llamada para verificar cuantos valores tiene llamada.Funcio_MEoIQ(Label,atributo,segundo_valor,N);//Obtiene el peso correspondiente a esta función Link(Label,segundo_valor,N); llamada_ImpE.Etiqueta_Entradas(Valor,segundo_valor); Label='N'; Link(Label,N,Num_Cons); Etiqueta("LTOE",Cadena_Funcion,N); } llamada.Funcio_Ent(Label,N,Num_Cons); Form1->positivo++; } if(funcion=="MAYOR_QUE"){ Bandera=1; int atributo; int B=0; //Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Valor=Form1->StringGrid2->Cells[4][n]; AnsiString Nomb=Form1->StringGrid2->Cells[3][n];//Obtiene el nombre del atributo B=ObjAnt.Verifica_SegundoValor_Neurona(Valor); if(B!=1){ float ValsCte= atof(Valor.c_str()); Label='I'; N=ObjAnt.Verifica_Neurona_Antecedente("GT", Nomb);//Verifica la existencia de esta funcion ObjAnt.Verifica_Tipo_Atributo(Label,N,Nomb,Valor);//llamada para verificar cuantos valores tiene Label='N'; Link(Label,N,Num_Cons); Etiqueta("GT",Nomb,N); llamada.Funcio_MAQ('I',Form1->atributo_activo,N,ValsCte);//Obtiene el peso correspondiente a esta función } else{ int segundo_valor; atributo=ObjAnt.Verifica_Neurona(Nomb);//Obtiene el num. de neurona de entrada Label='I'; AnsiString Cadena_Funcion= AnsiString(Nomb)+ AnsiString(Valor); N=ObjAnt.Verifica_Neurona_Antecedente("GT", Cadena_Funcion);//Verifica la existencia de esta funcion Link(Label,atributo,N);


124

llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); segundo_valor=ObjAnt.Verifica_Segundo_Valor_EnRed(Valor);//llamada para verificar cuantos valores tiene llamada.Funcio_MAQ(Label,atributo,segundo_valor,N);//Obtiene el peso correspondiente a esta función Link(Label,segundo_valor,N); llamada_ImpE.Etiqueta_Entradas(Valor,segundo_valor); Label='N'; Link(Label,N,Num_Cons); Etiqueta("GT",Cadena_Funcion,N); } llamada.Funcio_Ent(Label,N,Num_Cons);//coloca el WF en esa liga Form1->positivo++; } if(funcion=="MENOR_QUE"){ Bandera=1; int atributo; int B=0; //Se encarga de crear una neurona de entrada que forma parte de un antecedente AnsiString Valor=Form1->StringGrid2->Cells[4][n]; AnsiString Nomb=Form1->StringGrid2->Cells[3][n];//Obtiene el nombre del atributo B=ObjAnt.Verifica_SegundoValor_Neurona(Valor); if(B!=1){ float ValsCte= atof(Valor.c_str()); Label='I'; N=ObjAnt.Verifica_Neurona_Antecedente("LT", Nomb);//Verifica la existencia de esta funcion ObjAnt.Verifica_Tipo_Atributo(Label,N,Nomb,Valor);//llamada para verificar cuantos valores tiene Label='N'; Link(Label,N,Num_Cons); Etiqueta("LT",Nomb,N); llamada.Funcio_MEQ('I',Form1->atributo_activo,N,ValsCte); } else{ int segundo_valor; atributo=ObjAnt.Verifica_Neurona(Nomb);//Obtiene el num. de neurona de entrada Label='I'; AnsiString Cadena_Funcion= AnsiString(Nomb)+ AnsiString(Valor); N=ObjAnt.Verifica_Neurona_Antecedente("LT", Cadena_Funcion);//Verifica la existencia de esta funcion Link(Label,atributo,N); llamada_ImpE.Etiqueta_Entradas(Nomb,atributo); segundo_valor=ObjAnt.Verifica_Segundo_Valor_EnRed(Valor);//llamada para verificar cuantos valores tiene llamada.Funcio_MEQ(Label,atributo,segundo_valor,N);//Obtiene el peso correspondiente a esta función Link(Label,segundo_valor,N); llamada_ImpE.Etiqueta_Entradas(Valor,segundo_valor); Label='N'; Link(Label,N,Num_Cons); Etiqueta("LT",Cadena_Funcion,N);

} llamada.Funcio_Ent(Label,N,Num_Cons); Form1->positivo++; } if(Bandera==0){ AnsiString Nombre=""; Nombre=funcion; int B=0; for(int i=1;i< Form1->StringGrid1->RowCount;i++){ AnsiString Almacena=""; AnsiString Valor=Form1->StringGrid2->Cells[3][n]; Almacena=Form1->StringGrid1->Cells[1][i]; if(Nombre==Almacena){ B=1; Label='I'; ObjAnt.Verifica_Tipo_Atributo(Label,Num_Cons,Nombre,Valor);//llamada para verificar cuantos valores tiene llamada.Funcio_Ent(Label,Form1->atributo_activo,Num_Cons,Valor); break; } } if(B==0){ N=ObjAnt.Verifica_Neurona_Antecedente(Nombre); Label='N'; Link(Label,N,Num_Cons); Etiqueta(Nombre,N); llamada.Funcio_Ent(Label,N,Num_Cons); Form1->positivo++; } } Form1->atributo_activo=0; } //Archivo_Resumen: //Se encarga de obtener la información correspondiente para poder ser escrita //en un archivo de reporte, donde incluye las entradas, salidas, etc. de la red. void Func_Ant::Archivo_Resumen(){ Form1->Resumen.open(Form1->Nombre_rep.c_str(),ios::app); Form1->Resumen <<"CompSimb-Compilador de Reglas a Red Neuronal"<<endl; Form1->Resumen <<"Opcion de Compilación: " << Form1->Opcion.c_str()<<endl; Form1->Resumen.close(); //Se imprimen las neuronas utilizadas en archivo int tamno=inputs.size(); Form1->Resumen.open(Form1->Nombre_rep.c_str(),ios::app); Form1->Resumen << " " << endl; Form1->Resumen << "=> Entradas utilizadas:" << endl; Form1->Resumen << " " << endl; for(int i=0; i< tamno;i++){ Form1->Resumen <<" "<< inputs[i].nombre.c_str() << endl; } Form1->Resumen.close(); //Se llama a esta función para obtener las neuronas ocultas e imprimirlas en archivo llamada.Unidades_Ocultas(); Form1->Resumen.open(Form1->Nombre_rep.c_str(),ios::app); int reglas; //Se obtiene el numero de reglas reglas=Form1->_regl;


125

int Total_nodos; //Total_nodos toma el total de los nodos creados Total_nodos=Form1->Nu_Entrada+Form1->num_neuronas_ocultas; Form1->Resumen << " " << endl; Form1->Resumen <<"=> Salidas:"<<endl; Form1->Resumen << " " << endl; int size=Salidas.size(); int tamano=Numero.size(); for(int j=0;j<size;j++){ for(int i=0;i<tamano;i++){ if(Salidas[j].Num==Numero[i].Num) Form1->Resumen <<" "<< Numero[i].nombre.c_str()<<endl; } } Form1->Resumen.close(); //Se llama a esta función para obtener las entradas no utilizadas en la red llamada.Entradas_No_Utilizadas(); //Imprime en archivo en número, las entradas, salidas, capas, total de reglas,etc. Form1->Resumen.open(Form1->Nombre_rep.c_str(),ios::app); Form1->Resumen << " " << endl; Form1->Resumen <<"# Estadisticas:"<<endl; Form1->Resumen << " " << endl; Form1->Resumen <<"- Entradas: "<<Form1->Nu_Entrada<<endl; Form1->Resumen <<"- Ocultas: "<<Form1->num_neuronas_ocultas <<endl; Form1->Resumen <<"- Salidas: "<<Form1->num_neuronas_salida <<endl; Form1->Resumen <<"- Capas: "<<Num_capas<<endl; Form1->Resumen <<"+ Total de Reglas: "<<reglas<<endl; Form1->Resumen <<"+ Total de nodos: "<<Total_nodos<<endl; Form1->Resumen.close(); } //--------------------------------------------------------------------------- Verifica antecedentes //--------------------------------------------------------------------------- #include <vcl.h> #include <String.h> #include <fstream.h> #include <stdlib.h> #include <conio.h> #include <stdio.h> #include <vector.h> #include "compilacion_red.hpp" #include "red.hpp" #include "Unit4.h" #include "SHNS.h" #include "Func_Ant.hpp" #pragma hdrstop //--------------------------------------------------------------------------- red obj3,obj4; Func_Ant liga; vector<red> Consecuente(0); red Cons; vector<red> Antecedente(0); red Antec; vector<red> entrada_tipo(0); red neurona; vector<red> Entradas(0); red entrada; vector<red> Pesos(0); red Parametro_Peso; compilacion_red obj5; compilacion_red llamar; //Almacena_Neuronas:

//Función que guarda las unidades de entrada en un vector llamado entrada_tipo void red::Almacena_Neuronas(AnsiString nombre,AnsiString Tipo){ Form1->NoConsecutivo++; neurona.nombre=nombre; neurona.tipo=Tipo; neurona.valor=""; entrada_tipo.push_back(neurona); } //Almacena_Neuronas: //Función que guarda las unidades de entrada en un vector void red::Almacena_Neuronas(AnsiString Nomb_Atributo, AnsiString nombre_neurona,AnsiString Tipo){ Form1->NoConsecutivo++; neurona.nombre=Nomb_Atributo; neurona.valor=nombre_neurona; neurona.tipo=Tipo; entrada_tipo.push_back(neurona); } //Verifica_Neurona_Antecedente: //Verifica que la neurona ya este creada la unidad antecedente con el mismo tipo //y nombre de lo contrario hace una llamada a la funcion que la crea int red::Verifica_Neurona_Antecedente(AnsiString Tipo, AnsiString Nombre){ int B=0; int n=0; int tamano=Antecedente.size(); if(tamano!=0){ for(int i=0; i< tamano;i++){ AnsiString Nombre_neurona; AnsiString Tipo_Neurona; Nombre_neurona=Antecedente[i].nombre; Tipo_Neurona=Antecedente[i].tipo; if((Nombre_neurona==Nombre && Tipo_Neurona==Tipo)){ n=i;B=1; goto fin; } } } fin: if((tamano==0)||(B==0)){n=llamar.Almacena_Neuronas_Antecedentes(Tipo,Nombre); Form1->Nu_Antecedente++;} return(n); } //Verifica_Neurona: //Verifica repeticion de neuronas de entradas es decir si ya se encuentra creada int red::Verifica_Neurona(AnsiString Nombre){ int B=0; int n=0; int tamano=Entradas.size(); AnsiString Valor=""; AnsiString Nomb_NE; Valor=""; if(tamano!=0){ for(int i=0; i< tamano;i++){ AnsiString Valor_Neurona; Nomb_NE=Entradas[i].nombre; Valor_Neurona=Entradas[i].valor; if((Nomb_NE==Nombre && Valor_Neurona==Valor)||(Nomb_NE==Nombre && ((Valor_Neurona=="F")||(Valor_Neurona=="V")))){ n=i; B=1; goto fin; } } } fin:


126

if((tamano==0)||(B==0)){n=llamar.Almacena_Neuronas_Entrada(Nombre,Valor); Form1->Nu_Entrada++;} return(n); } //Verifica_Neurona //Verifica repeticion de neuronas de entradas es decir si ya se encuentra creada int red::Verifica_Neurona(AnsiString Nombre,AnsiString Valor_Atributo){ int B=0; int n=0; int tamano=Entradas.size(); AnsiString Valor=""; AnsiString Nomb_NE; Valor=Valor_Atributo; if(tamano!=0){ for(int i=0; i< tamano;i++){ AnsiString Valor_Neurona; Nomb_NE=Entradas[i].nombre; Valor_Neurona=Entradas[i].valor; if((Nomb_NE==Nombre && Valor_Neurona==Valor)||(Valor_Neurona=="")||(Nomb_NE==Nombre && ((Valor_Neurona=="F")||(Valor_Neurona=="V")))){ n=i; B=1; goto fin; } } } fin: if((tamano==0)||(B==0)){n=llamar.Almacena_Neuronas_Entrada(Nombre,Valor); Form1->Nu_Entrada++;} return(n); } //Verifica_SegundoValor_Neurona: //Verifica que ese valor sea un atributo de entrada. int red::Verifica_SegundoValor_Neurona(AnsiString Segundo_Valor){ int atributos=entrada_tipo.size(); int Bandera=0; AnsiString Nombre=""; AnsiString Nomb_NE; Nombre=Segundo_Valor; if(atributos!=0){ for(int i=0; i < atributos;i++){ Nomb_NE=entrada_tipo[i].nombre; if(Nomb_NE==Nombre){ Bandera=1;//Quiere decir que si forma parte de los atributos } } } return(Bandera); } //Verifica_Segundo_Valor_EnREd: //Función que verifica que el segundo valor con el cual es comparado es una //unidad ya creada, de lo contrario crearla siendo ligada a la unidad correspondiente int red::Verifica_Segundo_Valor_EnRed(AnsiString Nombre){ int B=0; int n=0; int tamano=Entradas.size(); AnsiString Nomb_Almacenado; AnsiString Valor=""; for(int i=0; i< tamano;i++){ Nomb_Almacenado=Entradas[i].nombre; if(Nomb_Almacenado==Nombre ){ n=i;

B=1; goto fin; } } fin: if(B==0){ n=llamar.Almacena_Neuronas_Entrada(Nombre,Valor); Form1->Nu_Entrada++; } return(n); } //Verifica_Neurona_Antecedente: //Verifica que el consecuente no se encuentre ya en el antecedente dando solo el nombre int red::Verifica_Neurona_Antecedente(AnsiString Nombre){ int B=0; int n=0; int tamano=Antecedente.size(); int size; AnsiString Temporal=""; size=int(Nombre.Length()); if(Nombre.c_str()[size-1]=='.'){ for(int i=0;i < size-1;i++) Temporal+=Nombre.c_str()[i]; } else{ Temporal=Nombre; } if(tamano!=0){ for(int i=0; i< tamano;i++){ AnsiString Nombre_neurona; Nombre_neurona=Antecedente[i].nombre; if((Nombre_neurona==Temporal)){ n=i;B=1; goto fin; } } } fin: if((tamano==0)||(B==0)){n=obj3.Verifica_Neurona_En_consecuente(Nombre);} return(n); } //Verifica_Neurona_En_consecuente: //Pasa a verificar si el antecedente no pertenece ya a un consecuente int red::Verifica_Neurona_En_consecuente(AnsiString Nombre){ int B=0; int n=0; int tamano=Antecedente.size(); int size; if(tamano!=0){ for(int i=0; i< tamano;i++){ AnsiString Nombre_neurona; Nombre_neurona=Antecedente[i].nombre; AnsiString Temporal=""; size=int(Nombre_neurona.Length()); if(Nombre_neurona.c_str()[size-1]=='.'){ for(int i=0;i < size-1;i++) Temporal+=Nombre_neurona.c_str()[i]; } else{ Temporal=Nombre_neurona; } if((Nombre==Temporal)){ n=i;B=1; goto fin; } } } fin:


127

if((tamano==0)||(B==0)){n=llamar.Almacena_Neuronas_Antecedentes(Nombre); Form1->Nu_Antecedente++;} return(n); } //Almacena_Neuronas_Entrada: //Almacena las unidades de entrada utilizadas int compilacion_red::Almacena_Neuronas_Entrada(AnsiString Nombre,AnsiString Valor_Ent){ entrada.nombre=Nombre; entrada.valor=Valor_Ent; Entradas.push_back(entrada); return(Form1->Nu_Entrada); } //Almacena_Neuronas_Antecedentes: //Almacena las unidades antecedentes con su tipo y nombre int compilacion_red::Almacena_Neuronas_Antecedentes(AnsiString Tipo,AnsiString Nombre){ Antec.tipo=Tipo; Antec.nombre=Nombre; Antecedente.push_back(Antec); return(Form1->Nu_Antecedente); } //Almacena_Neuronas_Antecedentes: //Almacena las unidades antecedentes solo con su nombre int compilacion_red::Almacena_Neuronas_Antecedentes(AnsiString Nombre){ Antec.nombre=Nombre; Antecedente.push_back(Antec); return(Form1->Nu_Antecedente); } //Verifica_Neurona_Valor:(llamada desde la función: Verifica_Tipo_Atributo) //Función para crear las unidades correspondientes a cada uno de los valores de //un atributo void red::Verifica_Neurona_Valor(char etiqueta,int Num_consecuente,AnsiString Nomb_Neurona, AnsiString Nomb_Valor){ int Num_Neurona; int size=entrada_tipo.size(); for(int j=0; j < size; j ++){ if((Nomb_Neurona==entrada_tipo[j].nombre)&&(Nomb_Valor==entrada_tipo[j].valor)){ Form1->atributo_activo=Verifica_Neurona(Nomb_Neurona,entrada_tipo[j].valor); liga.Link(etiqueta,Form1->atributo_activo,Num_consecuente); AnsiString Atributo_Valor=AnsiString(Nomb_Neurona)+"#"+AnsiString(entrada_tipo[j].valor); obj3.Etiqueta_Entradas(Atributo_Valor,Form1->atributo_activo); } if((Nomb_Neurona==entrada_tipo[j].nombre)&&(Nomb_Valor!=entrada_tipo[j].valor)){ Num_Neurona=Verifica_Neurona(Nomb_Neurona,entrada_tipo[j].valor); liga.Link(etiqueta,Num_Neurona,Num_consecuente); AnsiString Atributo_Valor=AnsiString(Nomb_Neurona)+"#"+AnsiString(entrada_tipo[j].valor);

obj3.Etiqueta_Entradas(Atributo_Valor,Num_Neurona); llamar.Funcion_Valores_Atributo(etiqueta,Num_Neurona,Num_consecuente); } } } //Verifica_Tipo_Atributo:(función llamada desde Func_Ant.cpp en Verificacion_de_antecedentes) //Función para determinar si es un atributo nominal, continuo, u ordenada para //llamar a la función que creará las unidades correspondientes a cada uno de sus valores void red::Verifica_Tipo_Atributo(char etiqueta,int Num_consecuente,AnsiString Nomb_Neurona, AnsiString Nomb_Valor){ AnsiString Tipo_Atributo; int size=entrada_tipo.size(); for(int j=0; j < size; j ++){ if(Nomb_Neurona==entrada_tipo[j].nombre){ Tipo_Atributo=entrada_tipo[j].tipo; goto continuar; } } continuar:; if(Tipo_Atributo=="NOMINAL" ||Tipo_Atributo=="CONTINUO"||Tipo_Atributo=="ORDENADAS" ){ Verifica_Neurona_Valor(etiqueta,Num_consecuente,Nomb_Neurona,Nomb_Valor); } else{ Form1->atributo_activo=Verifica_Neurona(Nomb_Neurona); liga.Link(etiqueta,Form1->atributo_activo,Num_consecuente); obj3.Etiqueta_Entradas(Nomb_Neurona,Form1->atributo_activo); } } //Atributo_Adicionales:(funcion llamada desde Asigna_Etiqueta) //Función para introducir los atributos adicionales en la red void red::Atributo_Adicionales(int num_renglon,char etiqueta,int consecuente){ AnsiString Nombre_Atributo_Adicional; AnsiString Temporal; int Num_Neurona_Adicional; int size=entrada_tipo.size(); for(int i=num_renglon+1;i<= Form1->StringGrid1->RowCount;i++){ Nombre_Atributo_Adicional=Form1->StringGrid1->Cells[1][i]; int tamano=int(Nombre_Atributo_Adicional.Length()); if(tamano!=0){ for(int i=0;i < size;i++){ if(Nombre_Atributo_Adicional==entrada_tipo[i].nombre){ Temporal=entrada_tipo[i].tipo; goto continuar; } } continuar:; AnsiString Nomb_Valor=""; if(Temporal=="NOMINAL" ||Temporal=="CONTINUO"||Temporal=="ORDENADAS" )


128

Verifica_Neurona_Valor(etiqueta,consecuente,Nombre_Atributo_Adicional,Nomb_Valor); if(Temporal=="RANGO" ||Temporal=="BINARIO"){ Num_Neurona_Adicional=Verifica_Neurona(Nombre_Atributo_Adicional); liga.Link(etiqueta,Num_Neurona_Adicional,consecuente); obj3.Etiqueta_Entradas(Nombre_Atributo_Adicional,Num_Neurona_Adicional); llamar.Funcio_Ent(etiqueta,Num_Neurona_Adicional,consecuente); } } } } //////////////////////////////////////////////////////////////////////////////// //Funciones de compilacion cálculo de pesos, bias y almacenamiento de los mismos //////////////////////////////////////////////////////////////////////////////// //Funcio_MAQ:(función llamada en el caso que su parámetro sea un valor constante) //almacenando su peso y bias void compilacion_red::Funcio_MAQ(char E, int a, int b,float ValCte){ obj3.W = Form1->Valor_Sensibilidad_MAQ; float temp= -1.0 * (ValCte - Form1->Valor_Confianza_MAQ); obj3.Bias = temp * Form1->Valor_Sensibilidad_MAQ; Almacena_Pesos(E, a, b, obj3.W,obj3.Bias); } //Funcio_MAQ:(función llamada en el caso que su parámetro sea un atributo) //almacenando su peso y bias void compilacion_red::Funcio_MAQ(char E, int a, int b, int c){ obj3.W = Form1->Valor_Sensibilidad_MAQ; obj4.W =-1.0 * Form1->Valor_Sensibilidad_MAQ; obj3.Bias = Form1->Valor_Confianza_MAQ * Form1->Valor_Sensibilidad_MAQ; Almacena_Pesos(E, a, c, obj3.W); Almacena_Pesos(E, b, c, obj4.W); Almacena_Pesos(c,obj3.Bias); } //Funcio_MoIQ:(función llamada en el caso que su parámetro sea un valor constante) //almacenando su peso y bias void compilacion_red::Funcio_MoIQ(char E, int a, int b,float ValCte){ obj3.W = Form1->Valor_Sensibilidad_MAQ; float temp= -1.0 * (ValCte - Form1->Valor_Confianza_MAQ); obj3.Bias = temp * Form1->Valor_Sensibilidad_MAQ; Almacena_Pesos(E, a, b, obj3.W,obj3.Bias); } //Funcio_MoIQ:(función llamada en el caso que su parámetro sea un atributo) //almacenando su peso y bias void compilacion_red::Funcio_MoIQ(char E, int a, int b, int c){ obj3.W = Form1->Valor_Sensibilidad_MoIQ; obj4.W = -1.0 * Form1->Valor_Sensibilidad_MoIQ; obj3.Bias = Form1->Valor_Confianza_MoIQ * Form1->Valor_Sensibilidad_MoIQ; Almacena_Pesos(E, a, c, obj3.W); Almacena_Pesos(E, b, c, obj4.W); Almacena_Pesos(c,obj3.Bias);

} //Funcio_MEQ:(función llamada en el caso que su parámetro sea un valor constante) //almacenando su peso y bias void compilacion_red::Funcio_MEQ(char E, int a, int b,float ValCte){ obj3.W = -1.0* Form1->Valor_Sensibilidad_MEQ; obj3.Bias = (ValCte + Form1->Valor_Confianza_MEQ)* Form1->Valor_Sensibilidad_MEQ; Almacena_Pesos(E, a, b, obj3.W,obj3.Bias); } //Funcio_MEQ:(función llamada en el caso que su parámetro sea un atributo) //almacenando su peso y bias void compilacion_red::Funcio_MEQ(char E, int a, int b,int c){ obj3.W = -1.0* Form1->Valor_Sensibilidad_MEQ; obj4.W = Form1->Valor_Sensibilidad_MEQ; obj3.Bias = Form1->Valor_Confianza_MEQ * Form1->Valor_Sensibilidad_MEQ; Almacena_Pesos(E, a, c, obj3.W); Almacena_Pesos(E, b, c, obj4.W); Almacena_Pesos(c,obj3.Bias); } //Funcio_MEoIQ:(función llamada en el caso que su parámetro sea un valor constante) //almacenando su peso y bias void compilacion_red::Funcio_MEoIQ(char E, int a, int b,float ValCte){ obj3.W = -1.0* Form1->Valor_Sensibilidad_MEQ; obj3.Bias = (ValCte + Form1->Valor_Confianza_MEQ)* Form1->Valor_Sensibilidad_MEQ; Almacena_Pesos(E, a, b, obj3.W,obj3.Bias); } //Funcio_MEoIQ:(función llamada en el caso que su parámetro sea un atributo) //almacenando su peso y bias void compilacion_red::Funcio_MEoIQ(char E, int a, int b,int c){ obj3.W = -1.0 * Form1->Valor_Sensibilidad_MEoIQ; obj4.W = Form1->Valor_Sensibilidad_MEoIQ; obj3.Bias = Form1->Valor_Confianza_MEoIQ * Form1->Valor_Sensibilidad_MEoIQ; Almacena_Pesos(E, a, c, obj3.W); Almacena_Pesos(E, b, c, obj4.W); Almacena_Pesos(c,obj3.Bias); } //Funcio_ER:(función formada por dos funciones GT y LT) //almacenando su peso y bias void compilacion_red::Funcio_ER(char E, int a, int b,int c){ obj3.W = Form1->factor_w_constante; obj4.W = Form1->factor_w_constante; obj3.Bias = -1.5 * Form1->factor_w_constante; Almacena_Pesos(E, a, c, obj3.W); Almacena_Pesos(E, b, c, obj4.W); Almacena_Pesos(c,obj3.Bias); } //Funcio_ER:(función formada por dos funciones GT y LT) //almacenando su peso y bias void compilacion_red::Funcio_IGUAL(char E, int a, int b,int c){ obj3.W = Form1->factor_w_constante; obj4.W = Form1->factor_w_constante; obj3.Bias = -1.5 * Form1->factor_w_constante; Almacena_Pesos(E, a, c, obj3.W); Almacena_Pesos(E, b, c, obj4.W); Almacena_Pesos(c,obj3.Bias); }


129

//Funcio_Not:(su valor de peso siempre será negativo) //almacenando su peso y bias void compilacion_red::Funcio_Not(char E, int a, int b){ obj3.W=(-Form1->factor_w_constante)/2; Almacena_Pesos(E, a, b, obj3.W); } //Funcio_Ent:(función utilizada para calcular el peso de antecedentes con valor de F o V) //almacenando su peso void compilacion_red::Funcio_Ent(char E, int a, int b, AnsiString V){ if(V=="F"){ Form1->positivo=Form1->positivo; obj3.W=-Form1->factor_w_constante; }else{ Form1->positivo++; obj3.W=Form1->factor_w_constante; } Almacena_Pesos(E, a, b, obj3.W); } //Funcio_Ent:(función utilizada para calcular el peso del antecedente al consecuente) //almacenando su peso void compilacion_red::Funcio_Ent(char E, int a, int b){ obj3.W=Form1->factor_w_constante; Almacena_Pesos(E, a, b, obj3.W); } //Funcio_Ent:(función llamada desde Verifica_Neurona_Valor() ) //Coloca el valor de peso a la unidad cuyo valor no fue utilizado void compilacion_red::Funcion_Valores_Atributo(char E, int a, int b){ obj3.W=-(Form1->factor_w_constante); Almacena_Pesos(E, a, b, obj3.W); } //Bias_Funcio_Cons: (funcion llamada desde Compilaci1click) //Se utiliza para obtener el bias de los consecuentes dependiendo si se trata //de una disyuncion (-w/2) o conjuncion((-2P+1/2)*w) void compilacion_red::Bias_Funcio_Cons(int a, char L){ if(L=='D'){ obj3.Bias=-(Form1->factor_w_constante)/2; }else{ float temp; temp=(-2* Form1->positivo + 1); obj3.Bias= (temp/2) * Form1->factor_w_constante; } Almacena_Pesos(a,obj3.Bias); } // Imprime: // Se encarga de imprimir en archivo el link, el peso que le corresponde y el bias void compilacion_red::Imprime(char a,int b,int c, float d){ Form1->Archivo_Red_wts.open(Form1->Nombre_wts.c_str(),ios::app); Form1->Archivo_Red_wts<<endl<< a <<" "<< b <<" "<< c <<" "<< d<<endl; Form1->Archivo_Red_wts.close(); } // Imprime: // Se encarga de imprimir en archivo el link, el peso que le corresponde y el bias

void compilacion_red::Imprime(char a,int b,int c,int d, float e){ Form1->Archivo_Red_wts.open(Form1->Nombre_wts.c_str(),ios::app); Form1->Archivo_Red_wts<<endl<< a <<" "<< b <<" "<< c <<" "<< d<<" "<< e <<endl; Form1->Archivo_Red_wts.close(); } //Almacena_Pesos:(llamada desde las Funciones de compilacion calculo de pesos, // bias y almacenamiento de los mismos) void compilacion_red::Almacena_Pesos(int a,float c){ Parametro_Peso.Link_etiqueta='B'; Parametro_Peso.Link_ant=a; Parametro_Peso.Link_cnt=0; Parametro_Peso.W=0; Parametro_Peso.Bias=c; int Funcion_Activacion=0; Pesos.push_back(Parametro_Peso); Imprime(Parametro_Peso.Link_etiqueta,Parametro_Peso.Link_ant,Parametro_Peso.W,Funcion_Activacion,Parametro_Peso.Bias); } //Almacena_Pesos:(llamada desde las Funciones de compilacion calculo de pesos, // bias y almacenamiento de los mismos) void compilacion_red::Almacena_Pesos(char E, int a, int b,float c){ Parametro_Peso.Link_etiqueta=E; Parametro_Peso.Link_ant=a; Parametro_Peso.Link_cnt=b; Parametro_Peso.W=c; Parametro_Peso.Bias=0; Pesos.push_back(Parametro_Peso); Imprime(Parametro_Peso.Link_etiqueta,Parametro_Peso.Link_ant,Parametro_Peso.Link_cnt,Parametro_Peso.W); } //Almacena_Pesos:(llamada desde las Funciones de compilacion calculo de pesos, // bias y almacenamiento de los mismos) void compilacion_red::Almacena_Pesos(char E, int a, int b,float c,float d){ Parametro_Peso.Link_etiqueta=E; Parametro_Peso.Link_ant=a; Parametro_Peso.Link_cnt=b; Parametro_Peso.W=c; Parametro_Peso.Bias=d; int freeze=0; int Funcion_Activacion=0; Pesos.push_back(Parametro_Peso); Imprime(Parametro_Peso.Link_etiqueta,Parametro_Peso.Link_ant,Parametro_Peso.Link_cnt,Parametro_Peso.W); Imprime('B',Parametro_Peso.Link_cnt,freeze,Funcion_Activacion,Parametro_Peso.Bias); } //Unicades_Ocultas:(funcion llamada desde Archivo_Resumen()) //Obtiene el nombre de las unidades ocultas del vector <Antecedente> void compilacion_red::Unidades_Ocultas(){ int tamno=Antecedente.size(); Form1->Resumen.open(Form1->Nombre_rep.c_str(),ios::app); Form1->Resumen << " " << endl; Form1->Resumen << "=> Unidades Ocultas:" << endl; Form1->Resumen << " " << endl; for(int i=0; i< tamno;i++){ Form1->Resumen<<" "<< Antecedente[i].nombre.c_str()<<" "<< endl;


130

} Form1->Resumen.close(); } //Entradas_No_Utilizadas:(funcion llamada desde Archivo_Resumen()) //Obtiene las entradas no utilizadas comparando el vector de <entrada_tipo> con <Entradas> void compilacion_red::Entradas_No_Utilizadas(){ int T=Entradas.size(); int size=entrada_tipo.size(); int B=0; int Temp; Form1->Resumen.open(Form1->Nombre_rep.c_str(),ios::app); Form1->Resumen << " " << endl; Form1->Resumen << "* Entradas no utilizadas:" << endl; Form1->Resumen << " " << endl; for(int i=0; i< size;i++){ for(int j=0; j< T;j++){ if(entrada_tipo[i].nombre==Entradas[j].nombre){ B=1; } } if(B==0){ Form1->Resumen <<" "<<entrada_tipo[i].nombre.c_str()<<endl; } B=0; } Form1->Resumen.close(); } //--------------------------------------------------------------------------- #include <vcl.h> #include <stdio.h> #include <conio.h> #include <dlgs.h> #pragma hdrstop #include "Unit4.h" #include "red.hpp" #include "Unit6.h" #include "SHNS.h" #include "compilacion_red.hpp" Especificación de parámetros //--------------------------------------------------------------------------- #pragma package(smart_init) #pragma resource "*.dfm" TForm4 *Form4; int K; red peso; //variable que guarda el peso de la red AnsiString cadena="";//Almacena el valor de los parámetros provisionalmente int bandera_edita; red Arch_Pesos; //Función que permite incrementar el valor del los parámetros dados como entrada //a la red neuronal artificial. void incrementar_valor(double valor, TEdit * E){ valor=valor + 0.01 ; cadena=valor; cadena.SetLength(6); E->Text =cadena; cadena=""; } //Función que permite decrementar el valor del los parámetros dados como entrada //a la red neuronal artificial. void decrementar_valor(double valor, TEdit * F){ valor=valor - 0.01 ; cadena=valor;

cadena.SetLength(6); F->Text =cadena; cadena=""; } //--------------------------------------------------------------------------- __fastcall TForm4::TForm4(TComponent* Owner) : TForm(Owner) { Edit1->Text = Form1->factor_w_constante; Edit6->Text = Form1->Valor_Confianza; Edit7->Text = Form1->Valor_Sensibilidad; BitBtn1->Enabled=false; } //--------------------------------------------------------------------------- //Variables que representan el valor de confianza, sensibilidad y factor de peso //para todas y cada una de las funciones utilizadas en los antecedentes. void __fastcall TForm4::BitBtn1Click(TObject *Sender) { Form1->Valor_Confianza_MAQ; //Valor_Confianza para la función Mayor que Form1->Valor_Sensibilidad_MAQ; //Valor_Sensibilidad para la función Mayor que Form1->Valor_Confianza_MoIQ; //Valor_Confianza para la función Mayor o igual que Form1->Valor_Sensibilidad_MoIQ; //Valor_Sensibilidad para la función Mayor o igual que Form1->Valor_Confianza_MEQ; //Valor_Confianza para la función Menor que Form1->Valor_Sensibilidad_MEQ; //Valor_Sensibilidad para la función Menor que Form1->Valor_Confianza_MEoIQ; //Valor_Confianza para la función Menor o igual que Form1->Valor_Sensibilidad_MEoIQ; //Valor_Sensibilidad para la función Menor o igual que Form1->Valor_Confianza_ER; //Valor_Confianza para la función en rango Form1->Valor_Sensibilidad_ER; //Valor_Sensibilidad para la función en rango Form1->Valor_Confianza_IGUAL; //Valor_Confianza para la función igual Form1->Valor_Sensibilidad_IGUAL; //Valor_Sensibilidad para la función igual Form1->factor_w_constante = atof(Edit1->Text.c_str());//valor del peso inicial de la RNA Form1->Compilacin1->Enabled=true; for(int i=0;i<2;i++){ } } //--------------------------------------------------------------------------- //Incrementa el valor del peso siendo este definido por el usuario void __fastcall TForm4::Button1Click(TObject *Sender) { Form1->factor_w_constante= atof(Edit1->Text.c_str()); incrementar_valor( Form1->factor_w_constante, Edit1); }


131

//--------------------------------------------------------------------------- //Decrementa el valor del peso siendo este definido por el usuario void __fastcall TForm4::Button2Click(TObject *Sender) { Form1->factor_w_constante= atof(Edit1->Text.c_str()); decrementar_valor(Form1->factor_w_constante, Edit1); } //--------------------------------------------------------------------------- //Obtiene la opcion de compilación void __fastcall TForm4::ComboBox1Click(TObject *Sender) { Form1->Nombre_top=Form1->Nombre + ".top"; Form1->Nombre_wts=Form1->Nombre + ".wts"; Form1->Nombre_rep=Form1->Nombre + ".rep"; if(ComboBox1->Text=="PAT"){ Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red_wts.open(Form1->Nombre_wts.c_str(),ios::in|ios::out); Form1->Archivo_Red_wts <<" "<<endl; Form1->factor_w_constante = (rand() % 100)/10.0; Edit1->Text = Form1->factor_w_constante; Form1->Opcion=ComboBox1->Text; } if(ComboBox1->Text=="PT"){ Form1->Archivo_Red.open(Form1->Nombre_top.c_str(),ios::app); Form1->Archivo_Red_wts.open(Form1->Nombre_wts.c_str(),ios::app); Form1->Archivo_Red_wts <<" "<<endl; Form1->Opcion=ComboBox1->Text; } BitBtn1->Enabled=true; Form1->Archivo_Red.close(); Form1->Archivo_Red_wts.close(); } //--------------------------------------------------------------------------- //Al dar click se permite la edición de los valores void __fastcall TForm4::Button5Click(TObject *Sender) { Edit6->ReadOnly=false; Edit7->ReadOnly=false; Button3->Enabled=false; Button4->Enabled=false; bandera_edita=0; } //--------------------------------------------------------------------------- //Incrementa el valor de confianza especificado por el usuario void __fastcall TForm4::Button12Click(TObject *Sender) { if(bandera_edita==0) { Form1->Valor_Confianza=atof(Edit6->Text.c_str()); incrementar_valor(Form1->Valor_Confianza, Edit6); } } //---------------------------------------------------------------------------

//Decrementa el valor de confianza especificado por el usuario void __fastcall TForm4::Button13Click(TObject *Sender) { if(bandera_edita==0) { Form1->Valor_Confianza=atof(Edit6->Text.c_str()); decrementar_valor(Form1->Valor_Confianza, Edit6); } } //--------------------------------------------------------------------------- //Incrementa el valor de Sensibilidad especificado por el usuario void __fastcall TForm4::Button14Click(TObject *Sender) { if(bandera_edita==0) { Form1->Valor_Sensibilidad=atof(Edit7->Text.c_str()); incrementar_valor(Form1->Valor_Sensibilidad, Edit7); } } //--------------------------------------------------------------------------- //Decrementa el valor de Sensibilidad especificado por el usuario void __fastcall TForm4::Button17Click(TObject *Sender) { if(bandera_edita==0) { Form1->Valor_Sensibilidad=atof(Edit7->Text.c_str()); decrementar_valor(Form1->Valor_Sensibilidad, Edit7); } } //--------------------------------------------------------------------------- //almacena los valores dados desde pantalla, en las variables correspondientes void __fastcall TForm4::Button20Click(TObject *Sender) { if(TabControl1->TabIndex==0){ Form1->Valor_Confianza_MAQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MAQ=atof(Edit7->Text.c_str()); } if(TabControl1->TabIndex==1){ Form1->Valor_Confianza_MoIQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MoIQ=atof(Edit7->Text.c_str()); } if(TabControl1->TabIndex==2){ Form1->Valor_Confianza_MEQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MEQ=atof(Edit7->Text.c_str()); } if(TabControl1->TabIndex==3){ Form1->Valor_Confianza_MEoIQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MEoIQ=atof(Edit7->Text.c_str());


132

} if(TabControl1->TabIndex==4){ Form1->Valor_Confianza_ER=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_ER=atof(Edit7->Text.c_str()); } if(TabControl1->TabIndex==5){ Form1->Valor_Confianza_IGUAL=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_IGUAL=atof(Edit7->Text.c_str()); } Edit6->ReadOnly=true; Edit7->ReadOnly=true; Button3->Enabled=true; Button4->Enabled=true; bandera_edita=1; } //--------------------------------------------------------------------------- //Guarda los valores desplegados en la página anterior botón (Atras) void __fastcall TForm4::Button3Click(TObject *Sender) { Edit6->ReadOnly=true; Edit7->ReadOnly=true; int temporal=0; temporal=TabControl1->TabIndex;//almacena el valor de la página actual TabControl1->TabIndex=temporal - 1; if(TabControl1->TabIndex==0){ Edit6->Text=Form1->Valor_Confianza_MAQ; Edit7->Text=Form1->Valor_Sensibilidad_MAQ; } if(TabControl1->TabIndex==1){ Edit6->Text=Form1->Valor_Confianza_MoIQ; Edit7->Text=Form1->Valor_Sensibilidad_MoIQ; } if(TabControl1->TabIndex==2){ Edit6->Text=Form1->Valor_Confianza_MEQ; Edit7->Text=Form1->Valor_Sensibilidad_MEQ; } if(TabControl1->TabIndex==3){ Edit6->Text=Form1->Valor_Confianza_MEoIQ; Edit7->Text=Form1->Valor_Sensibilidad_MEoIQ; } if(TabControl1->TabIndex==4){ Edit6->Text=Form1->Valor_Confianza_ER; Edit7->Text=Form1->Valor_Sensibilidad_ER; } K=TabControl1->TabIndex; } //--------------------------------------------------------------------------- //Guarda los valores desplegados en la página anterior botón (Sigte) void __fastcall TForm4::Button4Click(TObject *Sender) { Edit6->ReadOnly=true; Edit7->ReadOnly=true; int temporal=0; temporal=TabControl1->TabIndex;//almacena el valor de la página actual TabControl1->TabIndex=temporal + 1; if(TabControl1->TabIndex==1){ Edit6->Text=Form1->Valor_Confianza_MoIQ; Edit7->Text=Form1->Valor_Sensibilidad_MoIQ; }

if(TabControl1->TabIndex==2){ Edit6->Text=Form1->Valor_Confianza_MEQ; Edit7->Text=Form1->Valor_Sensibilidad_MEQ; } if(TabControl1->TabIndex==3){ Edit6->Text=Form1->Valor_Confianza_MEoIQ; Edit7->Text=Form1->Valor_Sensibilidad_MEoIQ; } if(TabControl1->TabIndex==4){ Edit6->Text=Form1->Valor_Confianza_ER; Edit7->Text=Form1->Valor_Sensibilidad_ER; } if(TabControl1->TabIndex==5){ Edit6->Text=Form1->Valor_Confianza_IGUAL; Edit7->Text=Form1->Valor_Sensibilidad_IGUAL; } K=TabControl1->TabIndex; } //--------------------------------------------------------------------------- //Permite almacenar el mismo valor para todas las funciones void __fastcall TForm4::RadioButton1Click(TObject *Sender) { Button20->Enabled=false; Button5->Enabled=false; Form1->Valor_Confianza_MAQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MAQ=atof(Edit7->Text.c_str()); Form1->Valor_Confianza_MoIQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MoIQ=atof(Edit7->Text.c_str()); Form1->Valor_Confianza_MEQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MEQ=atof(Edit7->Text.c_str()); Form1->Valor_Confianza_MEoIQ=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_MEoIQ=atof(Edit7->Text.c_str()); Form1->Valor_Confianza_ER=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_ER=atof(Edit7->Text.c_str()); Form1->Valor_Confianza_IGUAL=atof(Edit6->Text.c_str()); Form1->Valor_Sensibilidad_IGUAL=atof(Edit7->Text.c_str()); Edit6->Enabled=false; Edit7->Enabled=false; } //--------------------------------------------------------------------------- //Habilita la función de modificar los valores de los parámetros dados como default void __fastcall TForm4::RadioButton2Click(TObject *Sender) { Edit6->Enabled=true; Edit7->Enabled=true; Button20->Enabled=true; Button5->Enabled=true; Edit6->ReadOnly=true; Edit7->ReadOnly=true; Button3->Enabled=false;


133

Button4->Enabled=false; bandera_edita=1; } //--------------------------------------------------------------------------- void __fastcall TForm4::TabControl1MouseDown(TObject *Sender, TMouseButton Button, TShiftState Shift, int X, int Y) { TabControl1->TabIndex=K; } //---------------------------------------------------------------------------

//Llama a la forma que contiene la ayuda de las opciones de compilación void __fastcall TForm4::BitBtn2Click(TObject *Sender) { TForm6 *Form6; Form6=new TForm6(this); Form6->ShowModal(); } //---------------------------------------------------------------------------

134

ANEXO D DETALLE DE EXPERIMENTOS //Archivo simbolico: archivo_reglasR1,R2_monks.simb #INICIO #ATRIBUTOS HEAD_SHAPE : RANGO : [1,3]; BODY_SHAPE : RANGO : [1,3]; JACKET_COLOUR : RANGO :[1,4]. #FIN_ATRIBUTOS #REGLAS Monk1 :- IGUAL(HEAD_SHAPE,BODY_SHAPE); Monk1 :- IGUAL(JACKET_COLOUR, 1). #FIN_REGLAS #ATRIB_ADIC_USUARIO IS_SMILING : BINARIO :V/F; HOLDING : RANGO : [1,3]; HAS_TIE : BINARIO : V/F. #FIN // archivo_topología_R1,R2_monks. % % ANN creada automáticamente por CompSimb % $Network 6 1 4 9 $Connections I 0 1 1 2 N 1 2 3 3 N 3 3 0 0 I 2 2 5 6 N 5 6 7 7 N 7 7 4 4 N 0 0 8 8 N 4 4 8 8 O 8 8 I 3 5 8 8 $Labels 0 _Monk1.0 1 GT_HEAD_SHAPEBODY_SHAPE 2 LT_HEAD_SHAPEBODY_SHAPE 3 EQUAL_HEAD_SHAPEBODY_SHAPE 4 _Monk1.1 5 GT_JACKET_COLOUR 6 LT_JACKET_COLOUR 7 EQUAL_JACKET_COLOUR 8 _Monk1. $Inputs 0 HEAD_SHAPE 1 BODY_SHAPE 2 JACKET_COLOUR 3 IS_SMILING 4 HOLDING

5 HAS_TIE //Archivo de pesos_R1,R2_monks. 6 1 4 9 Compiled I 0 1 50 I 1 1 -50 B 1 0 0 2.5 I 0 2 -50 I 1 2 50 B 2 0 0 2.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4 B 0 0 0 -2 I 2 5 50 B 5 0 0 -47.5 I 2 6 -50 B 6 0 0 52.5 N 5 7 4 N 6 7 4 B 7 0 0 -6 N 7 4 4 B 4 0 0 -2 N 0 8 4 N 4 8 4 B 8 0 0 -2 I 3 8 4 I 4 8 4

Anexo D Detalle de experimentos

135

I 5 8 4 End //Archivo simbolico: archivo_reglas_R1.simb #INICIO #ATRIBUTOS HEAD_SHAPE : RANGO : [1,3]; BODY_SHAPE : RANGO : [1,3]. #FIN_ATRIBUTOS #REGLAS Monk1 :- IGUAL(HEAD_SHAPE,BODY_SHAPE). #FIN_REGLAS #ATRIB_ADIC_USUARIO JACKET_COLOUR : RANGO :[1,4]; IS_SMILING : BINARIO :V/F; HOLDING : RANGO : [1,3]; HAS_TIE : BINARIO : V/F. #FIN //Archivo_topología_R1.simb % % ANN creada automáticamente por CompSimb % $Network 6 1 3 4 $Connections I 0 1 1 2 N 1 2 3 3 N 3 3 0 0 O 0 0 I 2 5 0 0 $Labels 0 _Monk1. 1 GT_HEAD_SHAPEBODY_SHAPE 2 LT_HEAD_SHAPEBODY_SHAPE 3 EQUAL_HEAD_SHAPEBODY_SHAPE $Inputs 0 HEAD_SHAPE 1 BODY_SHAPE 2 JACKET_COLOUR 3 IS_SMILING 4 HOLDING 5 HAS_TIE //Archivo_pesos_R1.simb 6 1 3 4 Compiled I 0 1 50 I 1 1 -50 B 1 0 0 2.5 I 0 2 -50 I 1 2 50 B 2 0 0 2.5 N 1 3 4

N 2 3 4 B 3 0 0 -6 N 3 0 4 B 0 0 0 -2 I 2 0 4 I 3 0 4 I 4 0 4 I 5 0 4 End //Archivo simbolico: archivo_R2.simb #INICIO #ATRIBUTOS JACKET_COLOUR : RANGO :[1,4]. #FIN_ATRIBUTOS #REGLAS Monk1 :- IGUAL(JACKET_COLOUR, 1). #FIN_REGLAS #ATRIB_ADIC_USUARIO HEAD_SHAPE : RANGO : [1,3]; BODY_SHAPE : RANGO : [1,3]; IS_SMILING : BINARIO :V/F; HOLDING : RANGO : [1,3]; HAS_TIE : BINARIO : V/F. #FIN //Archivo_topología_R2 % % ANN creada automáticamente por CompSimb % $Network 6 1 3 4 $Connections I 0 0 1 2 N 1 2 3 3 N 3 3 0 0 O 0 0 I 1 5 0 0 $Labels 0 _Monk1. 1 GT_JACKET_COLOUR 2 LT_JACKET_COLOUR 3 EQUAL_JACKET_COLOUR $Inputs 0 JACKET_COLOUR 1 HEAD_SHAPE 2 BODY_SHAPE 3 IS_SMILING 4 HOLDING 5 HAS_TIE //Archivo_pesos_R2 6 1 3 4 Compiled I 0 1 50


136

B 1 0 0 -47.5 I 0 2 -50 B 2 0 0 52.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4 B 0 0 0 -2 I 1 0 4 I 2 0 4 I 3 0 4 I 4 0 4 I 5 0 4 End //Archivo simbolico: Categoria_Extra_7.simb #INICIO #ATRIBUTOS defectos_alarg_partiduras : RANGO : [0 , 6]; defectos_moteado : RANGO : [0 , 2.5]; defectos_varios : RANGO : [0 , 5]; tallo : BINARIO : V/F; Color_R : RANGO : [0,255]; Color_G : RANGO : [0,255]; Color_B : RANGO : [0,255]. #FIN_ATRIBUTOS #REGLAS Defectos:-EN_RANGO(Color_R,105,184), EN_RANGO(Color_G,90,158), EN_RANGO(Color_B,46,65), tallo(V), EN_RANGO(defectos_alarg_partiduras, 0 , 0 ), EN_RANGO(defectos_varios,0 , 0), EN_RANGO(defectos_moteado,0 , 0); Categoria_extra_golden:- Defectos. #FIN_REGLAS #FIN //Archivo de topología: Categoria_Extra % % ANN creada automáticamente por CompSimb % $Network 7 1 4 20 $Connections I 0 0 1 2

N 1 2 3 3 N 3 3 0 0 I 1 1 4 5 N 4 5 6 6 N 6 6 0 0 I 2 2 7 8 N 7 8 9 9 N 9 9 0 0 I 3 3 0 0 I 4 4 10 11 N 10 11 12 12 N 12 12 0 0 I 5 5 13 14 N 13 14 15 15 N 15 15 0 0 I 6 6 16 17 N 16 17 18 18 N 18 18 0 0 N 0 0 19 19 O 19 19 $Labels 0 _Defectos. 1 GT_Color_R 2 LT_Color_R 3 IN_RANGE_Color_R 4 GT_Color_G 5 LT_Color_G 6 IN_RANGE_Color_G 7 GT_Color_B 8 LT_Color_B 9 IN_RANGE_Color_B 10 GT_defectos_alarg_partiduras 11 LT_defectos_alarg_partiduras 12 IN_RANGE_defectos_alarg_partiduras 13 GT_defectos_varios 14 LT_defectos_varios 15 IN_RANGE_defectos_varios 16 GT_defectos_moteado 17 LT_defectos_moteado 18 IN_RANGE_defectos_moteado 19 _Categoria_extra_golden. $Inputs 0 Color_R 1 Color_G 2 Color_B 3 tallo 4 defectos_alarg_partiduras 5 defectos_varios 6 defectos_moteado //Archivo de pesos: Categoria_Extra. 7 1 4 20 Compiled I 0 1 10 B 1 0 0 -1049.5 I 0 2 -10 B 2 0 0 1840.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4


137

I 1 4 10 B 4 0 0 -899.5 I 1 5 -10 B 5 0 0 1580.5 N 4 6 4 N 5 6 4 B 6 0 0 -6 N 6 0 4 I 2 7 10 B 7 0 0 -459.5 I 2 8 -10 B 8 0 0 650.5 N 7 9 4 N 8 9 4 B 9 0 0 -6 N 9 0 4 I 3 0 4 I 4 10 10 B 10 0 0 0.5 I 4 11 -10 B 11 0 0 0.5 N 10 12 4 N 11 12 4 B 12 0 0 -6 N 12 0 4 I 5 13 10 B 13 0 0 0.5 I 5 14 -10 B 14 0 0 0.5 N 13 15 4 N 14 15 4 B 15 0 0 -6 N 15 0 4 I 6 16 10 B 16 0 0 0.5 I 6 17 -10

B 17 0 0 0.5 N 16 18 4 N 17 18 4 B 18 0 0 -6 N 18 0 4 B 0 0 0 -26 N 0 19 4 B 19 0 0 -2 End //Archivo simbolico: categoría_extra_5.simb #INICIO #ATRIBUTOS defectos_alarg_partiduras : RANGO : [0 , 6]; tallo : BINARIO : V/F; Color_R : RANGO : [0,255]; Color_G : RANGO : [0,255]; Color_B : RANGO : [0,255]. #FIN_ATRIBUTOS #REGLAS Defectos:-EN_RANGO(Color_R,105,184), EN_RANGO(Color_G,90,158), EN_RANGO(Color_B,46,65), tallo(V), EN_RANGO(defectos_alarg_partiduras, 0 , 0 ); Categoria_extra_golden:-Defectos. #FIN_REGLAS #ATRIB_ADIC_USUARIO defectos_moteado : RANGO : [0 , 2.5]; defectos_varios : RANGO : [0 , 5]. #FIN //Archivo de topología: Categoria_Extra_5. % % ANN creada automáticamente por CompSimb % $Network 7 1 4 14 $Connections I 0 0 1 2 N 1 2 3 3 N 3 3 0 0 I 1 1 4 5 N 4 5 6 6 N 6 6 0 0 I 2 2 7 8 N 7 8 9 9 N 9 9 0 0 I 3 3 0 0 I 4 4 10 11 N 10 11 12 12 N 12 12 0 0


138

N 0 0 13 13 O 13 13 I 5 6 13 13 $Labels 0 _Defectos. 1 GT_Color_R 2 LT_Color_R 3 IN_RANGE_Color_R 4 GT_Color_G 5 LT_Color_G 6 IN_RANGE_Color_G 7 GT_Color_B 8 LT_Color_B 9 IN_RANGE_Color_B 10 GT_defectos_alarg_partiduras 11 LT_defectos_alarg_partiduras 12 IN_RANGE_defectos_alarg_partiduras 13 _Categoria_extra_golden. $Inputs 0 Color_R 1 Color_G 2 Color_B 3 tallo 4 defectos_alarg_partiduras 5 defectos_moteado 6 defectos_varios //Archivo de pesos: Categoria_Extra_5 7 1 4 14 Compiled I 0 1 10 B 1 0 0 -1049.5 I 0 2 -10 B 2 0 0 1840.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4 I 1 4 10 B 4 0 0 -899.5 I 1 5 -10 B 5 0 0 1580.5 N 4 6 4 N 5 6 4 B 6 0 0 -6 N 6 0 4 I 2 7 10 B 7 0 0 -459.5 I 2 8 -10 B 8 0 0 650.5

N 7 9 4 N 8 9 4 B 9 0 0 -6 N 9 0 4 I 3 0 4 I 4 10 10 B 10 0 0 0.5 I 4 11 -10 B 11 0 0 0.5 N 10 12 4 N 11 12 4 B 12 0 0 -6 N 12 0 4 B 0 0 0 -18 N 0 13 4 B 13 0 0 -2 I 5 13 4 I 6 13 4 End //Archivo simbolico:Categroría_Extra_4.simb #INICIO #ATRIBUTOS defectos_alarg_partiduras : RANGO : [0 , 6]; defectos_moteado : RANGO : [0 , 2.5]; defectos_varios : RANGO : [0 , 5]; tallo : BINARIO : V/F. #FIN_ATRIBUTOS #REGLAS Defectos:-tallo(V),EN_RANGO(defectos_alarg_partiduras, 0 , 0 ), EN_RANGO(defectos_varios,0 , 0),EN_RANGO(defectos_moteado,0 , 0); Categoria_extra_golden:-Defectos. #FIN_REGLAS #ATRIB_ADIC_USUARIO Color_R : RANGO : [0,255]; Color_G : RANGO : [0,255]; Color_B : RANGO : [0,255]. #FIN //Archivo de topología: Categoria_Extra_4 % ANN creada automáticamente por CompSimb % $Network 7 1 4 11


139

$Connections I 0 0 0 0 I 1 1 1 2 N 1 2 3 3 N 3 3 0 0 I 2 2 4 5 N 4 5 6 6 N 6 6 0 0 I 3 3 7 8 N 7 8 9 9 N 9 9 0 0 N 0 0 10 10 O 10 10 I 4 6 10 10 $Labels 0 _Defectos. 1 GT_defectos_alarg_partiduras 2 LT_defectos_alarg_partiduras 3 IN_RANGE_defectos_alarg_partiduras 4 GT_defectos_varios 5 LT_defectos_varios 6 IN_RANGE_defectos_varios 7 GT_defectos_moteado 8 LT_defectos_moteado 9 IN_RANGE_defectos_moteado 10 _Categoria_extra_golden. $Inputs 0 tallo 1 defectos_alarg_partiduras 2 defectos_varios 3 defectos_moteado 4 Color_R 5 Color_G 6 Color_B //Archivo de pesos: Categoria_Extra_4 7 1 4 11 Compiled I 0 0 4 I 1 1 10 B 1 0 0 0.5 I 1 2 -10 B 2 0 0 0.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4 I 2 4 10 B 4 0 0 0.5 I 2 5 -10 B 5 0 0 0.5 N 4 6 4 N 5 6 4

B 6 0 0 -6 N 6 0 4 I 3 7 10 B 7 0 0 0.5 I 3 8 -10 B 8 0 0 0.5 N 7 9 4 N 8 9 4 B 9 0 0 -6 N 9 0 4 B 0 0 0 -14 N 0 10 4 B 10 0 0 -2 I 4 10 4 I 5 10 4 I 6 10 4 End //Archivo simbolico:todas_categorías.simb #INICIO #ATRIBUTOS defectos_alarg_partiduras : RANGO : [0 , 6]; defectos_moteado : RANGO : [0 , 2.5]; defectos_varios : RANGO : [0 , 5]; tallo : BINARIO : V/F; Color_R : RANGO : [0,255]; Color_G : RANGO : [0,255]; Color_B : RANGO : [0,255]. #FIN_ATRIBUTOS #REGLAS Categoria_extra :- EN_RANGO(Color_R,105,184),EN_RANGO(Color_G,90,158),EN_RANGO(Color_B,46,65),tallo(V), EN_RANGO(defectos_alarg_partiduras,0,0 ),EN_RANGO(defectos_varios,0,0), EN_RANGO(defectos_moteado,0,0); Categoria_I :- EN_RANGO(Color_R,92,145),EN_RANGO(Color_G,100,149),EN_RANGO(Color_B,40,59),tallo(V), EN_RANGO(defectos_alarg_partiduras,0.1,2),EN_RANGO(defectos_varios,0.1,1), EN_RANGO(defectos_moteado,0.1,0.25); Categoria_II :- EN_RANGO(Color_R,95,133),EN_RANGO(Color_G,110,138),EN_RANGO(Color_B,44,61),tallo(F),


140

EN_RANGO(defectos_alarg_partiduras,2.1,4),EN_RANGO(defectos_varios,1.1,2.5), EN_RANGO(defectos_moteado,0.26,1); Categoria_III :- EN_RANGO(Color_R,99,145),EN_RANGO(Color_G,98,139),EN_RANGO(Color_B,32,62),tallo(F), EN_RANGO(defectos_alarg_partiduras,4.1,6),EN_RANGO(defectos_varios,2.6,5), EN_RANGO(defectos_moteado,1.1,2.5). #FIN_REGLAS #FIN //Archivo topología:todas_categorías_7.simb % % ANN creada automáticamente por CompSimb % $Network 7 4 3 76 $Connections I 0 0 1 2 N 1 2 3 3 N 3 3 0 0 I 1 1 4 5 N 4 5 6 6 N 6 6 0 0 I 2 2 7 8 N 7 8 9 9 N 9 9 0 0 I 3 3 0 0 I 4 4 10 11 N 10 11 12 12 N 12 12 0 0 I 5 5 13 14 N 13 14 15 15 N 15 15 0 0 I 6 6 16 17 N 16 17 18 18 N 18 18 0 0 I 0 0 20 21 N 20 21 22 22 N 22 22 19 19 I 1 1 23 24 N 23 24 25 25 N 25 25 19 19 I 2 2 26 27 N 26 27 28 28 N 28 28 19 19 I 3 3 19 19 I 4 4 29 30 N 29 30 31 31 N 31 31 19 19 I 5 5 32 33 N 32 33 34 34 N 34 34 19 19 I 6 6 35 36 N 35 36 37 37 N 37 37 19 19 I 0 0 39 40 N 39 40 41 41 N 41 41 38 38 I 1 1 42 43 N 42 43 44 44

N 44 44 38 38 I 2 2 45 46 N 45 46 47 47 N 47 47 38 38 I 3 3 38 38 I 4 4 48 49 N 48 49 50 50 N 50 50 38 38 I 5 5 51 52 N 51 52 53 53 N 53 53 38 38 I 6 6 54 55 N 54 55 56 56 N 56 56 38 38 I 0 0 58 59 N 58 59 60 60 N 60 60 57 57 I 1 1 61 62 N 61 62 63 63 N 63 63 57 57 I 2 2 64 65 N 64 65 66 66 N 66 66 57 57 I 3 3 57 57 I 4 4 67 68 N 67 68 69 69 N 69 69 57 57 I 5 5 70 71 N 70 71 72 72 N 72 72 57 57 I 6 6 73 74 N 73 74 75 75 N 75 75 57 57 O 0 0 O 19 19 O 38 38 O 57 57 $Labels 0 _Categoria_extra. 1 GT_Color_R 2 LT_Color_R 3 IN_RANGE_Color_R 4 GT_Color_G 5 LT_Color_G 6 IN_RANGE_Color_G 7 GT_Color_B 8 LT_Color_B 9 IN_RANGE_Color_B 10 GT_defectos_alarg_partiduras 11 LT_defectos_alarg_partiduras 12 IN_RANGE_defectos_alarg_partiduras 13 GT_defectos_varios 14 LT_defectos_varios 15 IN_RANGE_defectos_varios 16 GT_defectos_moteado 17 LT_defectos_moteado 18 IN_RANGE_defectos_moteado 19 _Categoria_I. 20 GT_Color_R 21 LT_Color_R 22 IN_RANGE_Color_R 23 GT_Color_G 24 LT_Color_G 25 IN_RANGE_Color_G 26 GT_Color_B 27 LT_Color_B 28 IN_RANGE_Color_B 29 GT_defectos_alarg_partiduras 30 LT_defectos_alarg_partiduras 31 IN_RANGE_defectos_alarg_partiduras 32 GT_defectos_varios


141

33 LT_defectos_varios 34 IN_RANGE_defectos_varios 35 GT_defectos_moteado 36 LT_defectos_moteado 37 IN_RANGE_defectos_moteado 38 _Categoria_II. 39 GT_Color_R 40 LT_Color_R 41 IN_RANGE_Color_R 42 GT_Color_G 43 LT_Color_G 44 IN_RANGE_Color_G 45 GT_Color_B 46 LT_Color_B 47 IN_RANGE_Color_B 48 GT_defectos_alarg_partiduras 49 LT_defectos_alarg_partiduras 50 IN_RANGE_defectos_alarg_partiduras 51 GT_defectos_varios 52 LT_defectos_varios 53 IN_RANGE_defectos_varios 54 GT_defectos_moteado 55 LT_defectos_moteado 56 IN_RANGE_defectos_moteado 57 _Categoria_III. 58 GT_Color_R 59 LT_Color_R 60 IN_RANGE_Color_R 61 GT_Color_G 62 LT_Color_G 63 IN_RANGE_Color_G 64 GT_Color_B 65 LT_Color_B 66 IN_RANGE_Color_B 67 GT_defectos_alarg_partiduras 68 LT_defectos_alarg_partiduras 69 IN_RANGE_defectos_alarg_partiduras 70 GT_defectos_varios 71 LT_defectos_varios 72 IN_RANGE_defectos_varios 73 GT_defectos_moteado 74 LT_defectos_moteado 75 IN_RANGE_defectos_moteado $Inputs 0 Color_R 1 Color_G 2 Color_B 3 tallo 4 defectos_alarg_partiduras 5 defectos_varios 6 defectos_moteado //Archivo pesos:todas_categorías_7.simb 7 4 3 76 Compiled I 0 1 10 B 1 0 0 -1049.5 I 0 2 -10 B 2 0 0 1840.5 N 1 3 4 N 2 3 4 B 3 0 0 -6

N 3 0 4 I 1 4 10 B 4 0 0 -899.5 I 1 5 -10 B 5 0 0 1580.5 N 4 6 4 N 5 6 4 B 6 0 0 -6 N 6 0 4 I 2 7 10 B 7 0 0 -459.5 I 2 8 -10 B 8 0 0 650.5 N 7 9 4 N 8 9 4 B 9 0 0 -6 N 9 0 4 I 3 0 4 I 4 10 10 B 10 0 0 0.5 I 4 11 -10 B 11 0 0 0.5 N 10 12 4 N 11 12 4 B 12 0 0 -6 N 12 0 4 I 5 13 10 B 13 0 0 0.5 I 5 14 -10 B 14 0 0 0.5 N 13 15 4 N 14 15 4 B 15 0 0 -6 N 15 0 4 I 6 16 10 B 16 0 0 0.5


142

I 6 17 -10 B 17 0 0 0.5 N 16 18 4 N 17 18 4 B 18 0 0 -6 N 18 0 4 B 0 0 0 -26 I 0 20 10 B 20 0 0 -919.5 I 0 21 -10 B 21 0 0 1450.5 N 20 22 4 N 21 22 4 B 22 0 0 -6 N 22 19 4 I 1 23 10 B 23 0 0 -999.5 I 1 24 -10 B 24 0 0 1490.5 N 23 25 4 N 24 25 4 B 25 0 0 -6 N 25 19 4 I 2 26 10 B 26 0 0 -399.5 I 2 27 -10 B 27 0 0 590.5 N 26 28 4 N 27 28 4 B 28 0 0 -6 N 28 19 4 I 3 19 4 I 4 29 10 B 29 0 0 -0.5 I 4 30 -10

B 30 0 0 20.5 N 29 31 4 N 30 31 4 B 31 0 0 -6 N 31 19 4 I 5 32 10 B 32 0 0 -0.5 I 5 33 -10 B 33 0 0 10.5 N 32 34 4 N 33 34 4 B 34 0 0 -6 N 34 19 4 I 6 35 10 B 35 0 0 -0.5 I 6 36 -10 B 36 0 0 3 N 35 37 4 N 36 37 4 B 37 0 0 -6 N 37 19 4 B 19 0 0 -26 I 0 39 10 B 39 0 0 -949.5 I 0 40 -10 B 40 0 0 1330.5 N 39 41 4 N 40 41 4 B 41 0 0 -6 N 41 38 4 I 1 42 10 B 42 0 0 -1099.5 I 1 43 -10 B 43 0 0 1380.5 N 42 44 4 N 43 44 4


143

B 44 0 0 -6 N 44 38 4 I 2 45 10 B 45 0 0 -439.5 I 2 46 -10 B 46 0 0 610.5 N 45 47 4 N 46 47 4 B 47 0 0 -6 N 47 38 4 I 3 38 -4 I 4 48 10 B 48 0 0 -20.5 I 4 49 -10 B 49 0 0 40.5 N 48 50 4 N 49 50 4 B 50 0 0 -6 N 50 38 4 I 5 51 10 B 51 0 0 -10.5 I 5 52 -10 B 52 0 0 25.5 N 51 53 4 N 52 53 4 B 53 0 0 -6 N 53 38 4 I 6 54 10 B 54 0 0 -2.1 I 6 55 -10 B 55 0 0 10.5 N 54 56 4 N 55 56 4 B 56 0 0 -6 N 56 38 4

B 38 0 0 -22 I 0 58 10 B 58 0 0 -989.5 I 0 59 -10 B 59 0 0 1450.5 N 58 60 4 N 59 60 4 B 60 0 0 -6 N 60 57 4 I 1 61 10 B 61 0 0 -979.5 I 1 62 -10 B 62 0 0 1390.5 N 61 63 4 N 62 63 4 B 63 0 0 -6 N 63 57 4 I 2 64 10 B 64 0 0 -319.5 I 2 65 -10 B 65 0 0 620.5 N 64 66 4 N 65 66 4 B 66 0 0 -6 N 66 57 4 I 3 57 -4 I 4 67 10 B 67 0 0 -40.5 I 4 68 -10 B 68 0 0 60.5 N 67 69 4 N 68 69 4 B 69 0 0 -6 N 69 57 4 I 5 70 10 B 70 0 0 -25.5


144

I 5 71 -10 B 71 0 0 50.5 N 70 72 4 N 71 72 4 B 72 0 0 -6 N 72 57 4 I 6 73 10 B 73 0 0 -10.5 I 6 74 -10 B 74 0 0 25.5 N 73 75 4 N 74 75 4 B 75 0 0 -6 N 75 57 4 B 57 0 0 -22 End //Archivo simbólico :todas_categorías_5.simb #INICIO #ATRIBUTOS Color_R : RANGO : [0,255]; Color_G : RANGO : [0,255]; Color_B : RANGO : [0,255]; defectos_alarg_partiduras : RANGO : [0 , 6]; tallo : BINARIO : V/F. #FIN_ATRIBUTOS #REGLAS Categoria_extra :- EN_RANGO(Color_R,105,184),EN_RANGO(Color_G,90,158),EN_RANGO(Color_B,46,65), tallo(V),EN_RANGO(defectos_alarg_partiduras,0,0); Categoria_I :- EN_RANGO(Color_R,92,145),EN_RANGO(Color_G,100,149),EN_RANGO(Color_B,40,59), tallo(V),EN_RANGO(defectos_alarg_partiduras,0.1,2); Categoria_II :- EN_RANGO(Color_R,95,133),EN_RANGO(Color_G,110,138),EN_RANGO(Color_B,44,61), tallo(F),EN_RANGO(defectos_alarg_partiduras,2.1,4); Categoria_III :- EN_RANGO(Color_R,99,145),EN_RANGO(Color_G,98,139),EN_RANGO(Color_B,32,62),

tallo(F),EN_RANGO(defectos_alarg_partiduras,4.1,6). #FIN_REGLAS #ATRIB_ADIC_USUARIO defectos_moteado : RANGO : [0 , 2.5]; defectos_varios : RANGO : [0 , 5]. #FIN //Archivo topología :todas_categorías_5.simb % % ANN creada automáticamente por CompSimb % $Network 7 4 3 52 $Connections I 0 0 1 2 N 1 2 3 3 N 3 3 0 0 I 1 1 4 5 N 4 5 6 6 N 6 6 0 0 I 2 2 7 8 N 7 8 9 9 N 9 9 0 0 I 3 3 0 0 I 4 4 10 11 N 10 11 12 12 N 12 12 0 0 I 0 0 14 15 N 14 15 16 16 N 16 16 13 13 I 1 1 17 18 N 17 18 19 19 N 19 19 13 13 I 2 2 20 21 N 20 21 22 22 N 22 22 13 13 I 3 3 13 13 I 4 4 23 24 N 23 24 25 25 N 25 25 13 13 I 0 0 27 28 N 27 28 29 29 N 29 29 26 26 I 1 1 30 31 N 30 31 32 32 N 32 32 26 26 I 2 2 33 34 N 33 34 35 35 N 35 35 26 26 I 3 3 26 26 I 4 4 36 37 N 36 37 38 38 N 38 38 26 26 I 0 0 40 41 N 40 41 42 42 N 42 42 39 39 I 1 1 43 44 N 43 44 45 45 N 45 45 39 39 I 2 2 46 47 N 46 47 48 48 N 48 48 39 39 I 3 3 39 39 I 4 4 49 50


145

N 49 50 51 51 N 51 51 39 39 O 0 0 I 5 6 0 0 O 13 13 I 5 6 13 13 O 26 26 I 5 6 26 26 O 39 39 I 5 6 39 39 $Labels 0 _Categoria_extra. 1 GT_Color_R 2 LT_Color_R 3 IN_RANGE_Color_R 4 GT_Color_G 5 LT_Color_G 6 IN_RANGE_Color_G 7 GT_Color_B 8 LT_Color_B 9 IN_RANGE_Color_B 10 GT_defectos_alarg_partiduras 11 LT_defectos_alarg_partiduras 12 IN_RANGE_defectos_alarg_partiduras 13 _Categoria_I. 14 GT_Color_R 15 LT_Color_R 16 IN_RANGE_Color_R 17 GT_Color_G 18 LT_Color_G 19 IN_RANGE_Color_G 20 GT_Color_B 21 LT_Color_B 22 IN_RANGE_Color_B 23 GT_defectos_alarg_partiduras 24 LT_defectos_alarg_partiduras 25 IN_RANGE_defectos_alarg_partiduras 26 _Categoria_II. 27 GT_Color_R 28 LT_Color_R 29 IN_RANGE_Color_R 30 GT_Color_G 31 LT_Color_G 32 IN_RANGE_Color_G 33 GT_Color_B 34 LT_Color_B 35 IN_RANGE_Color_B 36 GT_defectos_alarg_partiduras 37 LT_defectos_alarg_partiduras 38 IN_RANGE_defectos_alarg_partiduras 39 _Categoria_III. 40 GT_Color_R 41 LT_Color_R 42 IN_RANGE_Color_R 43 GT_Color_G 44 LT_Color_G 45 IN_RANGE_Color_G 46 GT_Color_B 47 LT_Color_B 48 IN_RANGE_Color_B 49 GT_defectos_alarg_partiduras 50 LT_defectos_alarg_partiduras 51 IN_RANGE_defectos_alarg_partiduras $Inputs 0 Color_R 1 Color_G 2 Color_B 3 tallo 4 defectos_alarg_partiduras 5 defectos_moteado 6 defectos_varios

//Archivo pesos :todas_categorías_5.simb 7 4 3 52 Compiled I 0 1 10 B 1 0 0 -1049.5 I 0 2 -10 B 2 0 0 1840.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4 I 1 4 10 B 4 0 0 -899.5 I 1 5 -10 B 5 0 0 1580.5 N 4 6 4 N 5 6 4 B 6 0 0 -6 N 6 0 4 I 2 7 10 B 7 0 0 -459.5 I 2 8 -10 B 8 0 0 650.5 N 7 9 4 N 8 9 4 B 9 0 0 -6 N 9 0 4 I 3 0 4 I 4 10 10 B 10 0 0 0.5 I 4 11 -10 B 11 0 0 0.5 N 10 12 4 N 11 12 4 B 12 0 0 -6 N 12 0 4


146

B 0 0 0 -18 I 0 14 10 B 14 0 0 -919.5 I 0 15 -10 B 15 0 0 1450.5 N 14 16 4 N 15 16 4 B 16 0 0 -6 N 16 13 4 I 1 17 10 B 17 0 0 -999.5 I 1 18 -10 B 18 0 0 1490.5 N 17 19 4 N 18 19 4 B 19 0 0 -6 N 19 13 4 I 2 20 10 B 20 0 0 -399.5 I 2 21 -10 B 21 0 0 590.5 N 20 22 4 N 21 22 4 B 22 0 0 -6 N 22 13 4 I 3 13 4 I 4 23 10 B 23 0 0 -0.5 I 4 24 -10 B 24 0 0 20.5 N 23 25 4 N 24 25 4 B 25 0 0 -6 N 25 13 4 B 13 0 0 -18

I 0 27 10 B 27 0 0 -949.5 I 0 28 -10 B 28 0 0 1330.5 N 27 29 4 N 28 29 4 B 29 0 0 -6 N 29 26 4 I 1 30 10 B 30 0 0 -1099.5 I 1 31 -10 B 31 0 0 1380.5 N 30 32 4 N 31 32 4 B 32 0 0 -6 N 32 26 4 I 2 33 10 B 33 0 0 -439.5 I 2 34 -10 B 34 0 0 610.5 N 33 35 4 N 34 35 4 B 35 0 0 -6 N 35 26 4 I 3 26 -4 I 4 36 10 B 36 0 0 -20.5 I 4 37 -10 B 37 0 0 40.5 N 36 38 4 N 37 38 4 B 38 0 0 -6 N 38 26 4 B 26 0 0 -14 I 0 40 10 B 40 0 0 -989.5


147

I 0 41 -10 B 41 0 0 1450.5 N 40 42 4 N 41 42 4 B 42 0 0 -6 N 42 39 4 I 1 43 10 B 43 0 0 -979.5 I 1 44 -10 B 44 0 0 1390.5 N 43 45 4 N 44 45 4 B 45 0 0 -6 N 45 39 4 I 2 46 10 B 46 0 0 -319.5 I 2 47 -10 B 47 0 0 620.5 N 46 48 4 N 47 48 4 B 48 0 0 -6 N 48 39 4 I 3 39 -4 I 4 49 10 B 49 0 0 -40.5 I 4 50 -10 B 50 0 0 60.5 N 49 51 4 N 50 51 4 B 51 0 0 -6 N 51 39 4 B 39 0 0 -14 I 5 0 4 I 6 0 4 I 5 13 4

I 6 13 4 I 5 26 4 I 6 26 4 I 5 39 4 I 6 39 4 End //Archivos imbólico :t odas_categorías_4.simb //Archivo simbolico: prototipo.simb #INICIO #ATRIBUTOS defectos_alarg_partiduras : RANGO : [0 , 6]; defectos_moteado : RANGO : [0 , 2.5]; defectos_varios : RANGO : [0 , 5]; tallo : BINARIO : V/F. #FIN_ATRIBUTOS #REGLAS Categoria_extra :- tallo(V),EN_RANGO(defectos_alarg_partiduras,0,0 ),EN_RANGO(defectos_varios,0,0), EN_RANGO(defectos_moteado,0,0); Categoria_I :- tallo(V),EN_RANGO(defectos_alarg_partiduras,0.1,2),EN_RANGO(defectos_varios,0.1,1), EN_RANGO(defectos_moteado,0.1,0.25); Categoria_II :- tallo(F),EN_RANGO(defectos_alarg_partiduras,2.1,4),EN_RANGO(defectos_varios,1.1,2.5), EN_RANGO(defectos_moteado,0.26,1); Categoria_III :- tallo(F),EN_RANGO(defectos_alarg_partiduras,4.1,6),EN_RANGO(defectos_varios,2.6,5), EN_RANGO(defectos_moteado,1.1,2.5). #FIN_REGLAS #ATRIB_ADIC_USUARIO Color_R : RANGO : [0,255]; Color_G : RANGO : [0,255]; Color_B : RANGO : [0,255]. #FIN //Archivo topología :todas_categorías_4.simb % % ANN creada automáticamente por CompSimb % $Network 7 4 3 40 $Connections I 0 0 0 0 I 1 1 1 2 N 1 2 3 3 N 3 3 0 0


148

I 2 2 4 5 N 4 5 6 6 N 6 6 0 0 I 3 3 7 8 N 7 8 9 9 N 9 9 0 0 I 0 0 10 10 I 1 1 11 12 N 11 12 13 13 N 13 13 10 10 I 2 2 14 15 N 14 15 16 16 N 16 16 10 10 I 3 3 17 18 N 17 18 19 19 N 19 19 10 10 I 0 0 20 20 I 1 1 21 22 N 21 22 23 23 N 23 23 20 20 I 2 2 24 25 N 24 25 26 26 N 26 26 20 20 I 3 3 27 28 N 27 28 29 29 N 29 29 20 20 I 0 0 30 30 I 1 1 31 32 N 31 32 33 33 N 33 33 30 30 I 2 2 34 35 N 34 35 36 36 N 36 36 30 30 I 3 3 37 38 N 37 38 39 39 N 39 39 30 30 O 0 0 I 4 6 0 0 O 10 10 I 4 6 10 10 O 20 20 I 4 6 20 20 O 30 30 I 4 6 30 30 $Labels 0 _Categoria_extra. 1 GT_defectos_alarg_partiduras 2 LT_defectos_alarg_partiduras 3 IN_RANGE_defectos_alarg_partiduras 4 GT_defectos_varios 5 LT_defectos_varios 6 IN_RANGE_defectos_varios 7 GT_defectos_moteado 8 LT_defectos_moteado 9 IN_RANGE_defectos_moteado 10 _Categoria_I. 11 GT_defectos_alarg_partiduras 12 LT_defectos_alarg_partiduras 13 IN_RANGE_defectos_alarg_partiduras 14 GT_defectos_varios 15 LT_defectos_varios 16 IN_RANGE_defectos_varios 17 GT_defectos_moteado 18 LT_defectos_moteado 19 IN_RANGE_defectos_moteado 20 _Categoria_II. 21 GT_defectos_alarg_partiduras 22 LT_defectos_alarg_partiduras 23 IN_RANGE_defectos_alarg_partiduras 24 GT_defectos_varios 25 LT_defectos_varios

26 IN_RANGE_defectos_varios 27 GT_defectos_moteado 28 LT_defectos_moteado 29 IN_RANGE_defectos_moteado 30 _Categoria_III. 31 GT_defectos_alarg_partiduras 32 LT_defectos_alarg_partiduras 33 IN_RANGE_defectos_alarg_partiduras 34 GT_defectos_varios 35 LT_defectos_varios 36 IN_RANGE_defectos_varios 37 GT_defectos_moteado 38 LT_defectos_moteado 39 IN_RANGE_defectos_moteado $Inputs 0 tallo 1 defectos_alarg_partiduras 2 defectos_varios 3 defectos_moteado 4 Color_R 5 Color_G 6 Color_B //Archivo pesos :todas_categorías_4.simb 7 4 3 40 Compiled I 0 0 4 I 1 1 10 B 1 0 0 0.5 I 1 2 -10 B 2 0 0 0.5 N 1 3 4 N 2 3 4 B 3 0 0 -6 N 3 0 4 I 2 4 10 B 4 0 0 0.5 I 2 5 -10 B 5 0 0 0.5 N 4 6 4 N 5 6 4 B 6 0 0 -6 N 6 0 4 I 3 7 10 B 7 0 0 0.5 I 3 8 -10 B 8 0 0 0.5 N 7 9 4


149

N 8 9 4 B 9 0 0 -6 N 9 0 4 B 0 0 0 -14 I 0 10 4 I 1 11 10 B 11 0 0 -0.5 I 1 12 -10 B 12 0 0 20.5 N 11 13 4 N 12 13 4 B 13 0 0 -6 N 13 10 4 I 2 14 10 B 14 0 0 -0.5 I 2 15 -10 B 15 0 0 10.5 N 14 16 4 N 15 16 4 B 16 0 0 -6 N 16 10 4 I 3 17 10 B 17 0 0 -0.5 I 3 18 -10 B 18 0 0 3 N 17 19 4 N 18 19 4 B 19 0 0 -6 N 19 10 4 B 10 0 0 -14 I 0 20 -4 I 1 21 10 B 21 0 0 -20.5 I 1 22 -10 B 22 0 0 40.5

N 21 23 4 N 22 23 4 B 23 0 0 -6 N 23 20 4 I 2 24 10 B 24 0 0 -10.5 I 2 25 -10 B 25 0 0 25.5 N 24 26 4 N 25 26 4 B 26 0 0 -6 N 26 20 4 I 3 27 10 B 27 0 0 -2.1 I 3 28 -10 B 28 0 0 10.5 N 27 29 4 N 28 29 4 B 29 0 0 -6 N 29 20 4 B 20 0 0 -10 I 0 30 -4 I 1 31 10 B 31 0 0 -40.5 I 1 32 -10 B 32 0 0 60.5 N 31 33 4 N 32 33 4 B 33 0 0 -6 N 33 30 4 I 2 34 10 B 34 0 0 -25.5 I 2 35 -10 B 35 0 0 50.5 N 34 36 4 N 35 36 4


150

B 36 0 0 -6 N 36 30 4 I 3 37 10 B 37 0 0 -10.5 I 3 38 -10 B 38 0 0 25.5 N 37 39 4 N 38 39 4 B 39 0 0 -6 N 39 30 4 B 30 0 0 -10 I 4 0 4

I 5 0 4 I 6 0 4 I 4 10 4 I 5 10 4 I 6 10 4 I 4 20 4 I 5 20 4 I 6 20 4 I 4 30 4 I 5 30 4 I 6 30 4 End

cenidet · las manzanas en donde las reglas descriptivas y los ejemplos numéricos son conocidos,...

Documents