universidad autonoma metropolitana …148.206.53.84/tesiuami/uam5588.pdf · este trabajo tiene como...

UNIVERSIDAD AUTONOMA METROPOLITANA UNIDAD IZTAPALAPA

- C " b

1 L ric-

PROYECTO DE INVESTIGACION: 2 F _. I_

.- ~

i

PROFESOR: JOEL JIMEMEZ CRUZ

ALUMNO: MARIBEL VILLEGAS VALDIVIA /

c c9 I ' ' ~ ' ,- I' , 1 ' ' 1 li

INDICE

INTRODUCCIÓN ................................................................................. i

CAPITULO 1 . 0 BASES DE DATOS RELACIONALES . Definición .................................................................................... 5 . Operadores Relacionales ............................................................ 5 . Llaves y Ventajas ....................................................................... 6

CAPITULO 2 . 0 INTELIGENCIA ARTIFICIAL (AI)

. Definición .................................................................................... 9

. Comparación entre la Programación regular y

- Areas que abarca la AI ................................................................ 10 la Programación en AI ................................................................ 9

CAPITULO 3 . SISTEMAS EXPERTOS . Idea general ................................................................................... 13 - Características de un Sistema Experto ......................................... 13 - Componentes básicos Externos ..................................................... 13 - Componentes Internos ................................................................... 14

16 - Corrida del Sistema Experto ........................................................... 25 - Código de cada uno de los componentes Internos ........................

I

3.1. REDES NEURONALES . Definición ........................................................................ - Modelo de una Neurona - Arquitectura de las Redes Neuronales

.................................................. ............................

3.2. RAZONAMIENTO BASADO EN CASOS (C’BR) . Definición y características principales

. Desventajas del CBR ......................................................

.......................... . Ventajas del CBR ...........................................................

3.3. ALGORITMOS GENETICOS . Definición ........................................................................ . Componentes del Algoritmo Genético - Ventajas de los Algoritmos Genéticos - Desventajas de los Algoritmos Genéticos . Programación Genética ..................................................

...........................

........................... ......................

30 31 31

36 36 37

39 39 41 41 42

CAPITULO 4 . SISTEMAS DE PIZARRON . Concepto general ........................................................................... 44 - Comparación entre el Sistema Experto y el Sistema de Pizarrón

en diagrama de bloques ) ............................................................. 45 - Componentes de un Sistema de Pizarrón ...................................... 45 - Explicación y Descripción Algoritmica de cada uno de los

componentes del Sistema de Pizarrón .......................................... 47

APENDICE A ......................................................................................... 57 (Código fuente de un Sistema Experto)

APENDICE B ......................................................................................... 66 (Código fuente de un Sistema de Pizarrón)

BIBLIOGRAFIA .................................................................................... 85

... 111

INTRODUCCION

Este trabajo tiene como objetivo exponer que son las bases cit. datos inteligentes. y como han evolucionado a partir de las Bases de Datos tradicionales y los Sistemas Expertos, algunas de las Bases de Datos Inteligentes que se mencionan son : los Sistemas de Pizarrón. las Redes Neuronales. Casos Basados en el Razonamiento. y los Algoritmos Genéticos.

los

Pero, para entender todo lo anterior se tiene que empezar por. describir cada uno de los temas antes mencionados. para mostrar su importancia. h i i s Leiitrips. 4 así comprender los grandes alcances que éstas tienen en diferentes áreas conio: la cieiicia de la computación, la medicina, la psicología, la ingenieria. las matemiticas. la lógica. las ciencias naturales ..etc.

En el primer capítulo de este trabajo se tratari con las Bases de Datos Relacionales; que son sistemas computarizados que nos ayudan a iniiiiipiilar registros. estos registros se manejan con operadores relaciónales como: unión. selección y la proyección. Además todas las Bases de Datos tienen las operaciones básicas como la actualización, eliminación, inserción y la recuperación de componentes. ranibién se mencionan las ventajas que se obtienen cuando se iniplementa i i i i Sistema de Bases de Datos.

¿Que es la Inteligencia Artificial?. Es la pregunta obligada. J se tratar5 en el segundo capítulo. ya que s in ella no se podrían explicar los ciyuieiites tenias. porqiie de alguna forma los planteamientos restantes están relacionados con ella. i.n Inteligencia Artificial es un campo determinado de la computación el cual se deiine como: la imitación de las habilidades del intelecto humano dentro de una computadora. Adeinás st' mostraran

1

las diferencias que hay entre la programación normal inteligencia Artificial y las áreas que la iiltinia abarca para su aplicaci0ii.

la progr;iinrici6n quc iitilim la

Los Sistemas Expertos se tratarán en el tercer capítulo. estos coino SU i10111hre lo dice están enfocados a una tarea muy especifica. es decir q ~ i e puede h~ibcr Sistemas Expertos enfocados directamente sobre un tema en pcirticiilx. .ilguiiils Lie las características que los Sistemas Expertos debe contemplar stm: cxplicar sus conclusiones. que la interfaz que exista entre el usuario I I ~ coi7ipiitador;i t;ca c11 un lenguaje natural, aprender de el mismo .... etc. También se ~iiencionan 10s ccwpoiieiites externos e internos de un Sistema Experto con su código cot-respoiidieiite. E n t.1 iiiterior del trabajo se explicará la tarea de cada uno de los coniponeiites antes nieiicioniidos. j. en el apéndice 'A' se incluye el código completo del Sistema Experto.

Los tres temas siguientes se sitúan dentro del tercer capitulo porqiie dichos tenias son, diferentes alternativas que se pueden utilizar en los Sistemas Expertos.

Las Redes Neuronales: Una Red Neuronal es un coiijunto de procesadores paralelamente distribuidos que tiene la capacidad para almacenar c o n c ~ i iiiieiita de un tenia en particular. La neurona es la unidad fundaniental para la operaciiui LIc' Iii Kt.d Seuronal. está neurona recibe y manda información dependiendo de reglas j~ret.stiiblecicliis. 1. conio último se abarca al tema de la arquitectura de las redes neuronales.

En el Razonamiento Basado en Casos (CBR) se recuerdaii razonaniientos previos. situaciones similares que ocurren. y se usa esa experiencia para resoli er niie\-os problemas. Al recordar experiencias previas uno puede \.¡sualizar . m i i l i m - . criticar, mejorar y adaptar estas situaciones viejas. a soluciones nuevas. ai hacer esto se coiisigue un ahorro de tiempo y además se encuentran soluciones más optinias para el nue\ o problema. Se menciona además las ventajas y desventajas que se tienen al usar lo\ C'BR .

En los Algoritmos Genéticos se parte de un problema. ehte jx-ciblenia tiene solución dentro de un rango determinado. tomando en cuenta est? rcingo sr' gi'nera un conjunto de soiuciones (poblaciones). dichas poblaciones se permutan J coinbinan generando nuevas soluciones, ahora de estas nuevas soluciones se eligen las mt..jores o las más optimas para un problema determinado. Tomando eii cwiita ehtas wluciones (mejores) se repite el proceso de combinar y permutar para generar soluciones más aptas. Este proceso se sigue efectuando hasta que se cumpla una condición lacl la p o r patrones antes preestablecidos.

2

Y en el Último capítulo se menciona el Sistema de Pizari-On. cste h i s t e m tieiit. la siguiente idea general. Tenemos un grupo de expertos. cada uno es ;iltmeiire caliiicciclo en una área en particular. Se intenta coordinar el conociniieiito de c d , i uno Lie estos esyertos para resolver un problema especifico. ningún experto Iiahla con c i t r o cíirec tariieiitt'. lo hacen por medio de un pizarrón. en este pizarrón se escriben las pos ib les soluciones ( parciales ) hasta que en conjunto los expertos ctiicuentrcin I J ilic,ioi. soliición (generaí).Dentro del trabajo se ampliar6 esta idea y se iiieiicioiiariii los coi1ipoiieiites

internos y externos del Sistema de Pizarrón.

3

CAPITULO 1

BASES DE DATOS

e Datos IntcHgeo 4

/

/

1.- BASES DE DATOS

recuperación

actualización

eliminación

inserción

-4 y-

Una Base de Datos es un sistema computarizado para cl iiimteiiiniiento de registros. Dichos registros pueden trabajar con la ayuda de las operncioiics de iiinnipiilación de datos. Las operaciones son:

- recuperar - actualización - eliminación - inserción

SQL QBE YOMAND 1 (IBASE

select P. list j CI i splay

i update U. clia11ye 1 ieplace

delete D. delete de 1 et e j I

insert I. iiisert 1 .ippe lid , #

Cada sistema de bases de datos tiene su propio lenguaje. Al, ‘Tunos s o n

También es necesario recordar que la ma!oría de l L i h I3,i\es dc Ilatos son relaciónales; porque a cada renglón le corresponde exactamente un 1 r i l o i en cnch columna.

Para manipular el modelo relaciona1 se utiliza el álgebra relacioiinl. La cual tiene varios operadores como:

- selección: extrae un subconjunto de renglones de una tabla dada - proyección: extrae un subconjunto de columnas de una tabla - u n i h : reúne dos tablas para formar una nueva tabla

Otro punto importante de mencionar es el diseño de las base, <le < L i t o h ~oliiciotiar el problema de que registros debe tener la base de datos y clue campo5 citibeii coiitener dichos registros) ya que de este depende la eficiencia o ineficiencia del sistema

Ba nteligen 5

Para tener formas normales en las bases de datos se rieneIi C ~ I I C ‘ cot1sidcr:ii- :

- llave primaria: que es un campo o combinación de caiiipos CIC U I U td1l:i. c l ciial birve como un identificador único de los registros. ejemplos: In riintriciil:i dc I ; I i ’ \J1. cl iiiiiiiero del seguro social, etc.

- llave externa: es un campo o combinación de campos en una tabla cii! OS t <i\ores deben concordar con los de la llave primaria de otra tabla.

Ejemplos de llaves:

emp +lave yrimariu

s LIZ I do _ ~ _ L Num-emp Nombre Nuni-dep

L IILII’C’ C’.VIC’1‘17LI

dep 1 llaveprimaria ~ ~~ ~

\ liln-enlp _- Presupuesto ~

I Num-dep Nombre

L __- - I l t I i * C ~ C ’ S I l ’ l ’ I l L I

Ventajas de utilizar un sistema de bases de datos:

- Compatibilidad: Ya no tiene la necesidad de tener J giiarciai- ymcles \olliiiienes de documentación en papel.

- Velocidad: la computadora puede recuperar y modificar l a iiiforinac i t i i i ilc una manera mas rápida que cualquier persona.

- Disponibilidad: la información se mantiene en una forma e m x i J xtiidizacla .: esta disponible en cualquier momento .

- Menor fatiga: se eliminan las tareas tediosas como el niantenimiento cit. arcliii os.

- Manipulación de datos: permite borrar, cambiar. consultar. e iiiwrrai. c1ato.s cn ciialquier momento.

Bases de 6

A continuación se explicara lo que es la Inteligencia ,-\rtitici:iI. porque teniendo claros los conceptos de Bases de Datos y de Inteligencia Artiticilil se ~x)~li.Il ixisx al tema de Sistemas Expertos.

Bases de Datos Intelige 7

CAPITULO 2

INTELIGENCIA ARTIFICIAL

/

/

Datos Inteligent 8

INTELIGENCIA ARTIFICIAL

Existen un gran número de definiciones acerca de la inteligencia artif icial. en las siguientes definiciones se encuentran las principales ideas que estin cietriis cic la iiiteligencia artificial.

1. La inteligencia artificial es la imitación de las habilidades del iiitelccto h11i ; i t io Lictitro de una computadora.

2. La inteligencia artificial es un programa determinado de conipiitadara q iie prodiice iina salida considerada como una reflexión de la inteligencia generada por hiimaiios.

La forma de programación en la inteligencia artificial es diferente a In prcrgrniiinción regular, esta diferencia se hace explícita si se toma como punto de rctereiicia los tres componentes típicos de la programación regiiíar: las entradas. los procesos ! l a s d i d a s .

Programación Regular:

* Enfrudux- Es una secuencia de símbolos alfanuméricos que son presentados y almacenados para dar determinadas reglas y que utilizan tin medio cle coiiiiiiiicacibn tal como un teclado. disco magnético o cinta magnética.

* Proceso.- Aquí se manipulan los símbolos almacenados por tiiedin cte i i n rilpritmo definido anteriormente.

* Salida- Es una secuencia de símbolos alfanuméricos o gráficos. posiblt‘iiieiite dado por colores determinados, que representan el resultado del el proceso ! ciitt: A colocado sobre un medio de papel, disco o cinta magnética.

Esta programación tiende a ser inflexible en términos del tipo de riitrrida J salida. Si los datos de estructuras son necesarios, deben normalmente ser especificados durante el desarrollo de programas de computación. Como ejemplo se piiedeii iiieiicioiiar las Bases de Datos tradicionales.

Inteligentes 9

t - I Inteligencia Artificial

- . __ -1 d

Programación en la inteligencia artificial:

* Entradas.- Vista (una, dos y tres dimensiones), sonidci (leiigii~lt ' i~cd~i:do. inuslca y ruidos), tacto (temperatura, texturas), olfato (olores de objetos aniniLd)s c iiimimados) y gusto (dulce, agrio. salado).

* Procesos. - Las entradas son representadas, organizadas. almact.nxta~ J conlpmdas. por cualquiera de los diferentes procesos existentes: 1. Investigación..- Se encuentra la forma de representar los conceptos. 2. Lógico.- La forma de deducción de conceptos es supuesto y hecho. 3. Solución del problema.- La solución es planeada. ejecutada y oryanizada. 4. Aprendiendo.- Los nuevos conceptos son automáticaiiieiite adicioii,idos ! jxci irinieiite revisados.

* Salidas. - Lenguaje impreso. habla sintetizada y manipulación de n\?.ir-'tns físico-;.

Areas para desarrollar la AI:

- Lingüística - Ciencia Computarizada - Estadística - Matemáticas - Ingeniería - Etica - Psicología - Ciencias Naturales - Filosofia - Lógica - Física - Química

Bwesdy Datosbitdigentes 10

Con lo que hemos explicado hasta el momento concluimos C ~ L I C u n Sisteiiia 1Sxperto necesita de una Base de Datos que contenga la información necesaria para rcsolver los cuestionamientos que realicen lo usuarios.

Esta Base de Datos debe de estar conformada por las i-cylas dcfinicinnes necesarias para que el Sistema Experto sea capaz de dar las soluciones adecuadas a los planteamientos hechos por los usuarios. El Sistema Experto gracias ;i );I?> Bascs de Ihtos que lo componen es capaz de dar soluciones denominadas ..i iitcl igentes”( dt.bidn al supuesto “razonamiento*’ que realiza el sistema).

Para obtener dichas soluciones, estas Bases de Datos utilizan ;I oii‘os tipos de sistemas corno son: Redes Neuronales, Algoritmos Genkticos. C‘asos Basados e11 el Razonamiento(CBR). Sistemas de Pizarrón, etc.

En los siguientes capítulos se trata de explicar brevemente a lpnos de estos tipos de sistemas.

1 1

CAPITULO 3

SISTEMA EXPERTO

Bases de Datos Intefigen I ?

/

/

SISTEMA EXPERTO

Un sistema experto se puede usar para proporcionar ii!ut;i ;I l o s i iwiirios que desean conocer más profundamente sobre alguna área especitica. Este sistciiia se puede diseñar para facilitar algunas tareas, ya que contiene los conociniientos >. las CIC tiniciones necesarias para explicar sus métodos de solución proporcionando s i se ciesc'a. el modo de razonamiento de estas soluciones; la interfaz de estos sistemas permite que In iiiteracción con los usuarios resulte más sencilla a diferencia de los sistemas no espt'rtos.

El desarrollo de un sistema experto esta basado en el cniiociiiiiento de los ingenieros. además de sus conocimientos se necesita de una interacciihi entre el esperto y el programador, ésta interacción es supervisada por el ingeniero de coiiciciiiiieiito.

Las base de datos son necesarias para la creación de un sisteiiia cuperto. chtas bases de datos contienen la información necesaria para que el sistema ryxr to XYI q x i z de dar solución a los problemas planteados.

El sistema experto debe de cumplir con las siguientes características:

1. Debe de realizar una serie de preguntas en base a las cuales obtendri la información que

2. Dar una explicación del porqué de estas conclusiones. los que le denomina las líneas de

3. Que la interfaz que exista entre los usuarios y los in\xstigadores sea en i i i i lenguaje

4. Debe ser creado sin programación excesiva. 5. Recibir información (datos) desconocidos y asignarles un valor de certiduiiibre. 6. Aprender de él mismo.

necesita para poder dar soluciones adecuadas.

razonamiento.

natural.

Además de todas estas características el sistema experto esta cniistitiiido por cinco componentes externos básicos:

1. Sistema experto Es el más importante de todos, porque esta constituido de todo:, los Imyaiiias que resuelven el problema directamente sobre un campo de interés especiiico.

2. El experto Como su nombre lo indica es é l que conoce perfectamente el campo o Area de investigación, en base a su conocimiento y experiencia es capaz de encontrar l a

Bases de Datos Inteligent 13

solución adecuada al problema y también es la Única persona que conoce si los rcsiiltados obtenidos son correctos o no.

3. Los ingenieros de conocimiento. Los ingenieros son los individuos que generalmente conocen la constrLiccitit1 clcl sistema experto. Los ingenieros entrevistan a los expertos. organizan los c1nto.s ! clcciclcii un método de representación para los sistemas, adenik ajudan ;1 Io'r I'i'oci.~iiii~l~torec a escribir el código del sistema.

4. El lenguaje de programación. Elegir un lenguaje de programación que sea conveniente para representar los conceptos que son necesarios para elaborar el sistema. Y que ofrezca rapidez. xtiia1icl:id J sencillez en su utilización.

5. El usuario. El usuario es el individuo que va a hacer o que actualmente usa el sisteiiia esperto.

Los sistemas expertos están formados por tres componentes iiiteriins io> cuales se muestran a continuación. también: se presentara el código de cada uno de los componentes y en el apéndice 'B' se presentara el programa completo de un Sistema Esperto(en frutas ).

0 Memoria de trabajo

0 Base de Conocimiento.

0 Motor de Inferencia.

DIAGRAMA DE BLOQUES

de Trabajo inferencia c .)IlOClIll Itillto

Btrsrs de Datos lnteligentes 14

BASE DE CONOCIMIENTO

La base de conocimiento es una base de datos que contiene la int;wiiiicicin ! las reglas especificas para una área en particular. Esta base de coiiociiiiitinto esta coiistriiida tomando en cuenta a dos términos:

0 Objeto: es el resultado que se obtiene al definir cualidades ,t reglas t l i i u s

0 Atributo: es una cualidad que, con su regla, ayuda a definir el objeto.

Por lo tanto. considerarnos una base de conocimiento corm t ina lista LIC. oiiietos con sus reglas y atributos asociados.

Por ejemplo. un sistema experto que identifique distintos tipos de ti.tirLi podria tener una base de conocimiento como esta:

BASE DE CONOCIMIENTO

OBJETO

Manzana

I_! va

Naranja

ATRIBUTO

crece en un Arb01 redonda no crece en el sur roja o amarilla

crece en viñas pequeña \mios colores la viña no tiene espinas utilizable para \.¡nos

crece en un irbol redonda no puede crecer eii el norte narmja

Bases de Datos Inteligentes

0 Estnicturación de la Base de Conocimiento.

La Base de Conocimiento debe de estar formada por el notnhrt . de un objeto su lista de atributos ( como ya se menciono ). Una de las maneras para construir la parte que contiene al objeto es utilizando un arreglo con la siguiente estii c~tntcturCl

#define MAX 200

typedef struct atributo( char atrib[80]; struct atributo *siguiente;

:ATRIBUTO:

Debido a que no se conoce el número de atributos. la iista de dichos atributos es simplemente una lista ligada de esta estructura.

typedef struct objeto { char nombre[80]; ATRIBUTO * listaatributo;

}OBJETO;

Un Sistema Experto con la ayuda de su Base de Conociniiento puede determinar

El objeto es rechazado cuando el objeto no puede ser identificado por el Sistema cuando un objeto es rechazado o cuando es aceptado.

Experto , debido a que no cumple con las reglas definidas en el sisteiiia.

La estructura objeto-rechazado retiene el nombre de un ohieto rechazado y el atributo que causo su rechazo. El campo condición indica si el ol>ic.to carece de algún atributo o si contiene un atributo rechazado con anterioridad.

Cada vez que se rechace un objeto. sitúa dicho objeto ! su atributo en la Base de Datos rechazada.

Qpedef struct objetorechazado( char nombre[80]; char atrib[80]: char condición;

/*atributo que causo rechazo* '*lo necesitaba o no deberla*

)RECHAZADO; :*haber sido encontrado

Como se puede ver, la Base de Conocimiento debe controlar todos los atributos que pertenecen a un objeto determinado y de todos aquellos que no. La tiie.jor nianer;i de hacer

Bases de Datos Jnteligeates 16

1

- ----zIl ~. --

Sistemas Expertos; . - -- __I-

!

esto es usar dos listas enlazadas de la estructura tipo ATRIBUTO: 10s dos piiiiteros "si *' y "no" mostraran el principio de la lista. La variable global n g o s coiiticiic' el iiiiiiiero actual de los objetos dentro de la Base de Conocimiento. La variable glob;il r - y o 5 contiene el número actual de los objetos rechazados dentro de la estructura chicto iwliazacio.

RECHAZADO r-base[ M A XI;

OBJETO base-c[MAX]:

int rqos=- I : int ngos=- 1 ;

I* mantiene la base de coiiwiiiiit'iito~ /* localización de la ci i i ia de I J bn!,c /* localización de la ciinii de la hase de +

.'.

'*objrto_rechazacio

ATRIBUTO *si. *no, *siguienteno. *siguientesi;

0 Cargando la Base de Conocimiento.

El procediiiiieiito iiitroduce0 lee el nombre de i i n objeto J 411 lim cle atributos, y luego introduce dicha información en la Base de Conocimiento. Este proceso se repite hasta que el usuario teclea una línea en blanco. Entonces introduce() se dirige I-iacia otro objeto: el usuario puede introducir el nombre de otro objeto > sus atributos. o bien iiiia línea en blanco para detener el proceso de entrada.

void introduce() f

int t; ATRIBUTO *p. *anteriorg:

for( : ; ) {

t=obtiene-siguiente( ): ,'* obtiene el índice del siguiente objeto de la base-c */

if(t==-I)

printf("fuera del espacio de la lista.\n"); return:

1 printf("Nombre del objeto: ' I) :

gets(base-c[t].nombre); if(! *basec[t] .nombre) t

ngos--; break;

1

Bases de Datos Inteligentes 17

p=(ATRIBUTO *)riinlloc(sizeof( ATRIBUTO)); if( p=='\O') t

printf("Fuera de inemoria.\n"): return:

t base-c[t] .alista=p:

printf("1ntroduce los atributos (RETURN para salir)\n"); for(; ;> {

printf(" : "); gets(p->atrib): if (!p->atrib[O])

anteriorg=p: p->siguiente=( ATRIBUTO *)malloc(sizeof( ATRIBUTO)): p=p->siguiente: p->siguiente=NULL: if( p==N LT L L ) I

break;

printf("Fuera de memoria"); return;

1 1 anteriorq->siguiente='\O:

I 1

MOTOR DE INFERENCIA

Es la parte del sistema experto que intenta utilizar la inforniación que el usuario le suministra para encontrar un objeto que cumpla las características qiie ci iisiiario le da.

Hay tres formas básicas para construir el motor de inferencia:

0 Encadenamiento hacia adelante. O Encadenamiento hacia atrás. O Reglas de producción.

Bases de DatcM-Lteligeutes 18

Encadenamiento hacia adelante (Conducido por Datos)

El motor de inferencia utiliza la información que el usciariu le proporciona para moverse a traves de una red de AND's y OR's lógicos habta ~ L I C t'ilc'iientra i i i i punto terminal, que es el objeto.

Si se piensa en al Base de Conocimiento sobre la fruta descrita aiitcriorniente. se puede crear un diagrama que muestre c6mo un Motor de Inferencia de encadenamiento hacia adelante llegaría al objeto manzana. cuando se dan los atrihiios pertinentes. como lo muestra la tigural.

Manzana 0 tigura 1.

Como se puede ver un sistema de encadenamiento hacia xiclaiitc. ewici;ilniente construye un árbol desde las hojas hasta la raíz

- Bases de Datos ínteligen 19

Encadenamiento hacia atrás (Conducido por Objetos)

(un objeto) y pide la información necesaria para contirmario o 11cg;irio. Un Motor de Inferencia de encadenamiento hacia atrris coiiiicnzn con L I I U hipcitesis

Retomando el ejemplo de la base de conocimiento de la trLIt:l. hc ' cre~i un Lírbol aplicando como hipótesis la manzana. el cual se muestra en la figurii?.

n Intenta

arboles

+..N

redonda (1. Pequeña de

tamaño

Color Roja o naranja aniarilla

-. N

tigura2.


- - __ -_ I Sistemas Expertos I

i --__ --_I__

Reglas de Producción

Un Motor de inferencia de reglas de produccicín es te<iric:irnciitc supc'iior ;I un sistema de encadenamiento hacia atrás. porque pide la infornixioii q iic I-ccl~icc cl rango de la solución. Es decir que el sistema selecciona las preguntas que llexu1 n ~ i s rápidainente hacia una conclusión.

El problema de las reglas de producción está en su itiiplciiic.t-itacioii. 1';1 c l ~ r el método usado par3 su desarrollo tiene dos destemjas: e11 primer Itig;ir. I:I Bribe de Conocimiento es muy grande y el número de posibles coiiibinacioiit.\ euceclc 1 0 c1ue un sistema puede soportar con facilidad. Por io tanto. el bistema 110 piieclc \:her cual información lleva 1113s rápidamente hacia una solución. €ti srgiinclo lugar. lo\ \iiteni:is de reglas de producción requieren que la base de cniiociiiiiento contenga no wlo la información de objeto-atributo estáiidar. sino también titi \ nlor- c t i x i t i ticaeic)r ( iui iiiiiiiero

que sea determinante para saber que cuestionanientos son mis rele\ ntitc'h ). lo qiie tiact: aun más difícil la construcción de la Base de Coiiociiniento.

Para este programa se implemento un Motor de Inferencia cle ~iicacleiiiiiiiieito hacia atrás, por que la construcción del mismo es mas sencilla j. el tatiinfio cte la Base de Conocimiento es muy pequeña. pero puede crecer.

En seguida se mostrará el código para la implementacibn del 1 lotoi de Inferencia

0 Implementación del Motor de Inferencia

Ya que se cargó La información en la Base de Conocimiento \e piiecle tniplementar el Motor de Inferencia. El Motor de inferencia es el corazón del Sistema €\perto LA función más importante del Motor de Inferencia es pregunta(). que aparece '1 contmuacioii

void pregunta() c

int t; char ch: ATRIBUTO *p; for( t=O;t<=ngos;t+- )

c p=basec[t].aiista; if(intenta(p.base-c[t].nombre)) {

Base~ de Datos Inteiigeotes 21

.~ - - ~ .- - _ ___ Sistemas Expertos

_I- - - - -_

printf("'6s concuerda con la actual descripcionm".base _c[t].rioinbre): printf("continuo? (s,N)'*): ch= tolower(getch()); printf("\n"); if( ch=='n') return;

else

I*>>*/

I*<<*/

1 printf(" Objeto(s) no encontrado(s)"):

rechaza(base-c[t]. nom bre. p->atrib. In');

La función pregunta() es muy simple debido a que sirve iiiiicameiite como un controlador de la rutina principal intenta(). Esencialmente. pregunta( eilt ¡a ;I iiitenta() un objeto cada vez, hasta que. o bien intenta() encuentra en un plinto cltt uiiión. o hien la Base de Conocimiento se agota. La fiinción intenta() contiene la inteligeiicia cicl Motor de Inferencia como se muestra a continuación.

int intenta(ATFUBUT0 *p.char *ob)

{ char respuesta; ATRIBUTO *a,*t; if(! sigueno(p)) return O; if( !siguesi(p)) return O; whiie(p) { i* al siguiente atributo *,

/* si ya se ha preguntado entonces moverse*/

if( preg( p->atri b)) {

printf("es/ha/tiene ?/os ",p->atrib); respuesta=tolower(getch()): printf("\n");

a=( ATRIBUTO * jmalloc(sizeof(ATRIBUT0)); if(! a) {

printf("Fuera de rnemoriaul"); exit(0);

1 a->siguiente='\O':

Bascs de Datos 1ntWente.s

switch( respuesta) i

case In': strcp'ca- mrib.p->atrib); if( !no) I

no=a:

siguienteno=no;

1 else I siguienteno->siguiente=a; sigu ienteno=a:

t I* rechaza(ob, p->atrib. In');*/

return O: case Is': strcpy(a->atrib.p->atrib):

if(!si) i

si=a: siguientesi=si:

I

else {

sigu ientesi->sigu iente=a: siguientesi=a;

I p=p-%iguiente: break:

razonando(ob): break:

case 'p': I* por que? * I

} 1

else p=p->siguiente:

1 return( 1 );

1

La función intenta() trabaja de la siguiente manera. Primero Ins rutinas siguesi() y sigeno() comprueban la lista de atributos de cada objeto por el clue ~~as:nn. Las rutina siguesi() comprueba que los atributos del objeto son iguales a todo\ lo5 qiie especifica el usuario, y sigeno() comprueba que el objeto no tiene ninguno cie los mihiitos qiie hayan

Bases de Datos Inteiigentes 23

sido rechazados. La función preg() evita que un atrihiito se 17rcSuiitc doc; \cces. ,Aquí muestro las funciones de apoyo siguesi() sigueno() y preg( ).

int sigueno(ATRIBUT0 *p) t

ATRIBUTO *a. *t; a=no; wh ¡le( a) {

t=p; while( t) {

if(! ctrcmp(t->atrib,a->atrib))

t=t->siguiente; return O; /* tiene un atributo negativo * I

1 a=a->siguiente;

} return I ;

f

int siguesi(ATR1BUTO *p) t

ATRIBUTO *a,*t; char ok; a=& w h ¡le( a) {

ok=O; t=p; while( t) {

if(! strcmp( t->atri b.a-ratrib)) ok=l;

t==t->siguiente: !* no tiene un atributo negativo *

} if( ! o k )

a=a->siguiente: return O;

1 return 1 ;

I

Bases de Datos lnteiigent 24

int preg(char *atrib)

ATRIBUTO *p;

while(p && strcmp(atrib.p->atrib))

I p=si;

p=p->sigu iente;

if(!p) return I ;

return O;

'* falso si es el final de la lista *i else

}

Ya que se explicaron los componentes del Sistema Experto se presentar5 e n el todo el programa de Sistema Experto en frutas qiir' sc aixiliLó en este apéndice 'A'

proyecto.

C O W D A DEL SISTEMA EXPERTO E& FRIT;\S

0 Objetivo General.

- Mostrar el funcionamiento de un Sistema Experto.

Objetivos Especíiicos.

- Ejemplificar la Base de Conocimiento. - Ejemplificar el funcionamiento del Motor de Inferencia de encaden~iinit.iit~~ hacia atrás. - Mostrar el funcionamiento en particular de un Sistema Experto e n Frutas.

0 Utilidades.

- El código de un Sistema Experto es general, ya que si cambiamos el conteiiiito de la Base de Conocimiento tendremos un Sistema Experto en cualquier Area q ~ i e se Clc~c'e.

Para el Sistema Experto en Frutas una base de conocimiento podría ser:

Bases de Datos inteligeot 25

I

lp.-_-_ - ------------ - - - ._ --'i Sistemas Expertos

Objeto

Manzana

Cereza

Naranja

A tri but0

redonda. ha crecido en arbol roja o amarilla.

roja o amarilla. ha crecido en un Lirboi. pequeña.

redonda, ha crecido en un árbol. naranja.

Ahora para entender lo que hace el Motor de Inferencia pensenios 911e tenenios que escoger un objeto cualesquiera de la Base de Conocimiento. Naranja en este caso. ! por lo tanto el Sistema Experto tendrá el siguiente dialogo con el usuario:

Experto: usuario: Experto: Usuario: Experto: Usuario:

Experto: usuario: Experto:

es redonda ? si ha crecido en un árbol ? si roja o amarilla ? no I* rechaza manzana *I

es naranja ? si La Naranja cumple con la descripción.

/* hipótesis manzana y pregunta por su ier ritributo"/

I* rechaza cereza * I

Con la implementación del Motor de Inferencia de eiicadwamicnto hacia atrC?s se cumplen tres condiciones:

Bases de Dstos Inteligentes 26

0 El Sistema Experto no pregunta por el mismo atributo dos veces.

0 El Sistema Experto rechaza inmediatamente y . por lo tanto. cl ii,i ciiiilqiiicr ohleto que no tuviera uno o niás de los atributos necesarios conocidos. o qiic [ t i \ ICF'L cii1 ,itributn que hubiera sido rechazado con anterioridad.

0 Por medio de instrucciones (en este caso "p") el Sistema Experto c\ c a p w ilc coiitirmar por que está siguiendo una línea de razonamiento.

Para ejemplificar el tercer punto, siguiendo el ejettiplo antci'ioi.. tciwiiioh cl siciiicnte dialogo:

Experto: es redonda ? Usuario: si Experto: ha crecido en un árbol ? Usuario: si

Experto: roja o amarilla ? Usuario: p

Intentando Manzana es redonda ha crecido en un árbol

Experto: roja o amarilla ? Usuario: no Experto: naranja ? usuario: p

Intentando Naranja es redonda ha crecido en un árbol no es roja o amarilla

Experto: naranja '? Usuario: si

Bases de Datos 27

- - - 3 Sistemas Expertos __I__-----.. __ -

Manzana rechazada porque roja o amarilla es un atributo requerido Cereza rechazada porque roja o amarilla es un atributo requerido.

Experto: La naranja cumple con la descripción.

Los Sistemas Expertos fueron la base para otro tipo de sistenias Ilanindos Sisteinas de Bases de Datos Inteligentes KBS’s (por sus siglas en iiigles).

Los Sistemas Inteligentes KBS’s pueden utilizar otras teciiolosiah CIC coiiipiitlición. como son las Redes Neuronales. Algoritmos Genéticos. los C‘BR ( razoiiciiiiiento iiaslido en casos).

En los párrafos siguientes se dará una breye explicación dc estas twnologías. para explicar de que manera se usan dichas tecnologías en los Sistenias 1Jspertos. iniciando con las Redes Neuronales, los CBR, los Algoritmos Genkticos >- los Sisteiiicis ctc Pizarrón ( son sistemas inteligentes que utilizan varios Sistemas Expertos).

Bases de patos bteiigent

Redes Neuronales -~ i - -

CAPITULO 3.1

REDES NEURONALES

h s e s ile Diatos inteligentes 29

rp Redes Neuronales - 3

3.1 REDES NEURONALES

Una Red Neuronal es un conjunto de procesadures paraleiaiiiciitc dihti-ihiiictos que tienen la capacidad de almacenar conocimiento de un tenia en particiiix.

Para su desarrollo. las redes neuronales emplean una iiitercniieliciii i i ix iva de celdas, llamadas "neuronas" o "unidades de procesamiento -..

A continuación se dará una breve descripción del iiiodeio de una iiciiroiia

Modelo de una neurona

Una neurona es una unidad de procesamiento de inforiiiaciciii qiie es tundaniental para la operación de una Red Neuronal. esta neurona recibe J iiiniidri iiitorniaci6ii tomando en cuenta reglas antes preestablecidas (Le condiciones ehtablecidas por el usuario o reglas que están definidas en la Base de Conocimiento). En la siguiente figura se muestra el modelo.

Sinápticos

Modelo de una neurona

En la figura se pueden identificar tres elementos básicos:

1. Señales de Entrada.- Cada una se caracteriza por un peso sinápticu o t'iici-m propia.

Base!#"üe Datos Inteligentes 30

2. Una sumatoria para adicionar las señales de entrada. Esta cipcraciciii coiistitu! t' una combinación lineal.

3. Una función de activación para limitar la amplitud de la salida clc I I I iicciroiiii I. : i tiiiición de activación también se llama función limitadora por clue l i m i u c l r ~ i i i p ) ~ i c miplitud de una determinada salida. Típicamente. la amplitud iioriiidimc1:i clcl rango Jc. I L L ~ i l ida de una neurona esta dentro de en un intervalo cerrado de [O.i 1 o ~ i l tc i . i i~ i t i \ .L i i i i~ i i t~ I- I . I ] .

ARQUITECTURA DE LAS REDES

La manera en la cual las neuronas de una red se estructuraii esta l igxto con el algoritmo de aprendizaje que se usa en el desarrollo de la red.

Redes de una capa alimentada hacia adelante

Cuando la forma de la red tiene solamente una capa. tenemos iiiia capa de eiitrada de los nodos fuente ( i ) que se proyectan sobre la capa de salida de las neiiroiias( hi ). pero no viceversa. Por lo anterior, esta red es estrictamente del tipo de alimeiitacion Iiaci~i adelante. La red es llamada red de una sola capa. por que se hace referencia a la capa de salida de las neuronas. No se cuenta la capa de entrada en los nodos fiiente. porque el proceso de computación no se realiza aquí.

Capa di: entrada Capa LIS \cllld'l

de los nodos fuente di: la\ neurona\ Figural.

Bases de Datos ínteiigentes

Redes multicapas alimentadas hacia adelante.

La segunda clase de redes neuronales alimentadas hacia ac!el;iiitc se distinguen por la presencia de una o más capas escondidas. que en términos conipiitiicioiinles soti llaniadas neuronus esconúidcis o unidades escondi~lus. La función de e s i x iicuronas es la de intervenir entre la entrada externa y la salida de la red.

Los nodos fuente en la capa de entrada de la red . coiistitii! cii I;I ~ ~ 7 ; i l c s de entrada aplicadas sobre la neuronas en la primera capa. Las señales de siilidii 3c I;\ priiiiera capa se usan como entradas de la segunda capa y así para el resto de In red. I.;i i irclii itwtura del grafo en la figura 2 ilustra una red multicapas de alimentación hacia ;ictcIxitc piira cl caso de una sola capa oculta. Esta red se conoce como 9-4-2. en cionde 0 so11 los iiocios de entrada, 4 los nodos ocultos y 2 los nodos de salida.

Capa de entrada de los nodos fuente

Capa aplicada a las neurona?;

Figura 2.

32

-~ Redes Neuroaaies 1111

Redes recurrentes

Una red Neural recurrente se distingue de las cicmii; i-cdcs p)rqiic recibe información de las mismas neuronas que la conforman. es decir. las sciiiilcs de cntrada a una neurona, son las señales de salida de todas las neuronas restantes. l’oi- cjciiiplo. uiia red recurrente puede consistir de una capa simple de neuroiias. en doiicit. cada sciiai de salida. regresa como señal de entrada para alguna otra neurona. como sc \-e en la ti9ui-a 3 .

I I

4 “ii-lip0 L k operadores de

I retraso.

iigeo

Figura 3.

Como se dijo anteriormente las Redes Neuronales se pueden i i t i I i / x cn iin Sistema

Para explicar la manera en que el sistema utiliza la red iiciir:ii. h e ~lcscribira de Experto.

manera general el funcionamiento del Sistema Experto.

El Sistema Experto pregunta y el usuario responde. ai iiioiiiciito de i.cywiicier el sistema llama al Motor de Inferencia y este. en base a las respiiestx ctcl iisiwio cnciieiitra la solucion del problema en particular.

Ahora si se introduce la Red Neuronal dentro del Sistema 1Jsperto su funcionamiento seria el siguiente : El Sistema Experto cuestiona > el usuario i-espoiide, al responder el usuario, el sistema llama a la Red Neronal (Las respuestas del usuario se toman como entradas de la red) y mediante su funcionamiento la red obtiene i in coijunto de posibles soluciones. en seguida el sistema llama al Motor de Iiifertncix qiic l<)iii;ira como referencia los resultados obtenidos por la red, y asi encontrara la h o i i i c i o i i gc'nerril del problema.

Bases de D eo 34

r - ~

Razonamiento Basado en Casos t ___ -~ -1

CAPITULO 3.2

RAZONAMIENTO BASADO EN CASOS

35

/

/

I!, 3 -~

~ . -. Razonamiento m c i o en Casos ---

3.2 RAZONAMIENTO BASADO EN C ' t S O S

La idea general que hay detrás del razonamiento basado cii CCISOS ( c ' l 3 R ) . es la siguiente, se recurre a razonamientos previos en situaciones siiiiiixcs. ! h c l isa esta experiencia como ayuda para resolver problemas nuevos.

El CBR puede ser el medio para adaptar algunas soluciones ;interiores ;I soliiciones convencionales o nuevas. Se usan casos anteriores para explicar i i t ie\x soliicioiies. para interpretar con razonamientos precedentes a las n u e \ a soliicioiies. o p m crear una solución equitativa a un problema nuevo. La referencia de casos pre\,ios siiiiiliires es a menudo necesario para tratar con casos complejos y nue\.os.

Como consecuencia del razonamiento está el aprendimje. porque p x i llegar al razonamiento se tiene que interpretar un problema y esto da coiiio resiilrado el qxmdizaje. Por lo tanto el CBR es a la vez un modelo aparente de razonamieiito J. u i i modelo para construir sistemas inteligentes.

En general el CBR depende de cinco características bisicas:

1. Debe de existir una experiencia previa. 2. Debe tener la "habilidad" de entender nuevas situaciones en t t t r i i i i i iob de sit iiaciones

3. Debe tener la "habilidad" de integrar nuevas experiencias dentro de l o5 casos apropiados. 4. Reparación y evaluación. 5. Adaptación.

previas.

En el CBR se aprende primeramente por acumulación de nile\ os c;~sos. 1.n extensión del aprendizaje en el razonamiento puede depender de el rango de c\Iwieiici:i5 que este tiene, esta facultad habilita la ejecución y previene las decisiones e r r i h u .

Ventajas de los CBR:

Ahorro de tiempo. ya que al usar los casos anteriores se piiedeii resn l \~r los casos nuevos de una manera mas rápida.

0 Los CBR proporcionan los medios para evaluar las soluciones. ciiaiido iiiiiciiii iiit-todo algorítmico esta disponible para su evaluación.

Bas igeotes 36

Razonamiento-Basado en Casos ~ _ _ - -7 --i

e Recurrir a las experiencias previas es particularmente Uti1 p i r a prexmir a 10s nuevos casos de acciones erróneas.

Desventajas de los CBR:

Los CBR dependen de la experiencia previa para evaluar si el resultado es ccwccto o incorrecto y por lo tanto se necesita de una gran variedad de casos anteriores para obtener óptimos resultados en los nuevos casos.

Los CBR dan un conjunto de soluciones y uno tiene que decidir cual es 13 optiiiia para el problema en particular.

La gente que utiliza los CBR debe conocerlos y debe saber especiticni el prc)bleiiici para reconocer las soluciones posibles y determinar el resultado opt imo p x a el problema en particular.

Los Sistemas Expertos también pueden usar CBR. En el c;iso de inipleinentnr un sistema con CBR se tendrían que introducir casos previos dentro de la Base C'oiiocirniento y ayudarse de ellos para encontrar soluciones nuevas. El uso de los C'BR tendría lugar en el Motor de Inferencia. Ai igual que en las Redes Neuronales el coii.jiinto de solticiones que obtenga el CBR serán la base para que el Motor de inferencia enciientrc la soliicicin del problema.

Bases de Dat nt 37

CAPITULO 3.3

ALGORITMOS GENETICOS

Bases de Da 38

/

/

- -

r ~ -+ Algoritmos Genéticos ,&.&. A',<,, - -

3.3 ALGORITMOS GENÉTICOS

Para explicar la idea que está detrás de los algoritiiios ceiicticos. toiiiiii-mios por ejemplo a los conejos. Existe una población de conejos. algiinos de cllos soii iiiiis rápidos y más listos, tienen nienos probabilidad de que sean comidos por l o 5 lol~os. ~olvc\.ii;iendo para producir más conejos. Por supuesto. los conejos qiie son leiitos > iio tiiii!. listos no sobrevivirían tan fácilmente como los otros. Esta poblacibii de coticjos clue sobrevive. empieza a crear una raza de conejos. Los conejos de esta raza sc coinbinan coii al, (vinos conejos: algunos conejos lentos, con cone-jos rápidos. rapidos coii rripictos. etc. liesultando conejos que serian diferentes a la población en general.( i.e sobre\,i\-t.ii los coiie.jos inás aptos)

Un algoritmo genético sigue paso a paso el procedimiento clue anteriorniente se mencionó en los conejos.

Los algoritmos genéticos usan un vocabulario derik ado cie I,i gciietica ii'itiirai. Se habla acerca de individuos (o genotipos, estructuras). en una poblacinii. cilyiiiia\ eces estos individuos se llaman también cadenas o cromosomas. Los croiiiosotiias estaii hechos de unidades (genes) unidos en una sucesión lineal.

Los algoritmos genéticos logran una búsqueda iiiiiltidireccioii~il entre la población de las soluciones potenciales y de la información generada: intercanihiaiido cntre estas dos direcciones. La población hará una evolución simulada: sobre ciicla pieración. las soluciones relativamente buenas se reproducen, mientras que las i-elatix aiiiente iiialas mueren. Para la distinción entre las diferentes soluciones se usa iina tiiiicióii (e t olución) objetivo, la cual es de mucha importancia.

Todas las combinaciones y mutaciones que se realizan nos producen i i i i espacio de posibles soluciones que pudiera tener un determinado problema. con este espacio nos da una mejor visión de las soluciones. de las cuales solo tomara las iiiciores cie todo este espacio y no toma en cuenta los valores que prodiicirían u i i i-edtado iiiiilo para el problema.

Un algoritmo genético para un problema en particiilai &her coiiieiier cinco componentes :

- Una representación genética para las soluciones potenciales del pi-ohleiiia - Un camino para crear una población inicial de soluciones potenciales. - Una función de evaluación que es la regla del medio ambiente. eiicoiitr;indo soluciones en términos de su optimalidad.

Bases de Datos lnteligen 39

Algor¡tmos Cenéticos -__ - --__ -

- Operadores genéticos que alteren la composición de los individuos ( croiiiosoiiias ) durante la reproducción. - Valores para varios parámetros que usa el algoritmo genkticn (t:iiiiafio ctc in ~ J o I J I x ~ ~ ~ , probabilidad de mutación. etc.).

La aplicación más comun de los Algoritmos Geneticos i i ~ i b i c i o I L L hoIiiciOii de problemas de optimización, en donde han mostrado ser m u y eticiciitch ! coiilid3lt.s. Sin embargo, no todos los problemas pudieran ser apropiados para la ticiiica. ! se iwoiiiienda en general tomar en cuenta las siguientes características:

Su espacio de búsqueda ( Le., sus posibles soluciones) debe estar deIiinitado t ' i i i i i i cierto rango.

Debe poderse detinir una función de amplitud que nos indique cliit' taii hiiciin o iiialii es una cierta respuesta.

Las soluciones deben codificarse de una forma que resulte relati\mientc tiicil de implementar en la computadora.

El primer punto es muy importante, y lo más eficiente es inteiitar resol\ er problemas que tengan espacios de búsqueda discretos ( aunque éstos sean mu" grandes ). Siii embargo, también puede intentarse utilizar la técnica con espacios de biisqiiedn coiitiiiiins. pero preferentemente cuando exista un rango de soluciones relativainente pc'qiit.fi0.

La función de aptitud, es un término que se usa en los algoritmos geneticos. 4 no es más que la función objetivo de nuestro problema de optimización. El algoritmo geiiético únicamente maximiza. pero la minimización puede realizarse ficiliiieiite iitilizando el recíproco de la función maximizante (debe cuidarse. por supuesto. qiie el recíproco de la función no genere una división entre cero). Una característica que debe teiier est,? función es que tiene que ser capaz de distinguir a las malas soluciones y desecharlas. ! de elegir a las buenas, de forma que sean estas últimas las que se propaguen con inci! or rapidez.

La codificación más común de las soluciones es por niedio clc cdeiias hiiiarias, aunque se han utilizado también números reales y letras. El primero cit. esto> csqiieiiias ha gozado de mucha popularidad debido a que es muy fácil de iniplementar.

Bases de Datos in 40

Ventajas al utilizar Algoritmos Genéticos:

e No necesitan conocimientos específicos sobre el problema que intciita resol \u. o Operan de forma simultánea con varias solucioiies. eii vez de traixi.i:ir c k torma

secuencia1 como las técnicas tradicionales. o Cuando se usan para problemas de optimización - i-iiasiniizar iiii;i tiiiicioii ol3,ietivo -

resultan menos afectados por los máximos locales (falsas solucicmes) CI tic' las ttiiiicas tradicionales.

e Resulta fácil ejecutarlos en las modernas arquitecturas inasivamciitc pa ix l c la .

Desventajas al utilizar Algoritmos Genéticos

Pueden tardar mucho en converger, o no converger en absoluto. depeiidieiido eii cierta medida de los parámetros que se utilicen - tamaño de la población. niiiiiero de generaciones. etc .-

o Pueden converger prematuramente debido a una serie de problemas de d i 1 ersa iiidole

Los Sistemas Expertos pueden usar Algoritmos Geneticos para su desarrollo. El uso de los Algoritmos Genéticos tendría lugar e n ~ e l Motor de Inferencia. A1 igwi que en las Redes Neuronales y en los CBR el conjunto de soluciones que obtenga el algoritnio serán la base para que el Motor de inferencia encuentre la solución del problema.

Datos Inteligeot 41

7 Algoritmos Gen¿ticos , ,4 :

I

Programación genética

El paradigma de la programación genética (PG). propuesto por .ioliii KOLI. t's una extensión de los algoritmos genéticos, que difiere de éstos por la ti)riii:i C I I qiic rcprcsciita a los individuos de la población, pues utiliza programas de computadorLi CI I I i i y i . C ~ C cdenas de longitud fija. La meta de la PG es lograr que las computadoras aprt 'ndui ;I resolver problemas sin ser explícitamente programadas, la PG trata LIC. gciicrar soliicioiies a problemas a partir de la inducción de programas. El programador no especific:i cl taiiiaño,

evolucionando hasta generar soluciones sofisticadas. forma y complejidad estructural de los programas-solución sino que los pro2 ~'rallias van

Las razones para formular los problemas por inducción de pro- (Tramas son tres:

1. Los programas de computadora tienen la flexibilidad necesaria para cs1ires;ir soluciones en una amplia variedad de problemas.

2. Los programas de computadora pueden tomar el tamaño. la torina J Iii complejidad estructural necesario para resolver estos problemas.

3. La PG proporciona una metodología para facilitar el uso de la inducción de pro_, ('ramas.

En la PG, las poblaciones de cientos de miles de programas dt' coiiipiit,idora son reproducidos genéticamente. Esta reproducción utiliza el principic) Jc suiit'r\ ¡\.encia y reproducción del más apto descrito anteriormente.

Después de que las operaciones de reproducción y cruce son e.ieciitadas en la reeinplaza a la población actual, la población de descendencia ( i.e la nueva generation

población vieja ( i.e. la generación vieja).

Generalmente. el mejor individuo que aparece en cualquier seneraci¿)n cle una corrida ( i.e, el mejor individuo por el momento) es designado conio el resultiicto producido por la PG.

B nteligeotes 42

CAPITULO 4

SISTEMAS DE PIZARRON

Bases de Datxmbteligentes 43

SISTEMAS DE PIZARRON

Los sistemas de pizarrón son un fenómeno reciente que pt-okce h;~scs para una arquitectura abstracta de gran poder y generalidad. Estos ruonar emulando encadenamientos hacia adelante y hacia atrás. o coinhi naiido a t n h t i w n a s de razonamiento oportunamente.

sistciiias piiecicii

La idea detrás del modelo de pizarrón se puede explicar i n t i i t t i \ 'iiiietitc coino sigue: Tenemos un grupo de expertos, cada uno de los cuales es altamente cnliticado cn itti campo específico. Estamos intentando coordinar el conocimiento de estos expertos prira resolver un problema difícil, ningún experto habla con otro directamente. pero para ri>wdar a resolver el problema acuerdan como interactuar con un coordinador o planificnctor > como leer y escribir sobre un pizarrón.

Los expertos recopilan la información en un pizarrón. escriben la declaración inicial del problema. leen la declaración del problema y comienzan ;I pcnsar. Lii la iiiedida en que cada uno de los expertos llega a una hipótesis importante. la csci-ibe t'ti el pizarrón para que cada uno de los otros expertos la pueda ver. Esto ayiicia a los t'\rpertc.is en su pensamiento, ya que cuentan con indicios importantes basados eii cotioci niiento tiiera de su propio dominio. Con el tiempo, uno de los expertos podrá resol\w el prohleina ! escribir la solución final en el pizarrón.

La interacción de los expertos como se define anteriormente es algci anirqiiico. y el conjunto necesita estar bien organizado para así resolver el problema. En cualquier momento habrá un número de expertos cuyo conocimiento se apiicn cii el contenido del pizarrón, pero no están autorizados a modificar la información en el p t z a r r h SI tio sería un caos.

Tomando en cuenta la explicación anterior los sistemas cic p t m l - o i 1 h c pueden considerar como el conjunto de varios sistemas expertos.

Cuando este modelo se utiliza en un contexto de sistemas expertos. Iliimainos a cada uno de los expertos participantes como una fuente de conocimiento. [.tia fiietite de conocimiento no es literalmente un experto humano. si no que se I t : coiisicierri 1111 co1i.jiinto de conocimientos de una área en particular. El pizarrón se utiliza para coiiipartir la hipótesis e información entre las fuentes del conocimiento.

Dado un conjunto de problemas a resolver. el equipo de espertos ticticti tin iiiiiiiero de ventajas:

Bases de Dat 44

Es fácil de añadir nuevos expertos durante el proceso de resolver prohleiiicis >e1 clue toda la información requerida por los expertos se puede localizar e n el pi/Lun)Ii.

0 Areas diferentes de un mismo problema se pueden c i i i c i l i i x ~iiii~ilt~ii~~'tll lelite por grupos distintos de expertos, gracias a que toda la iiiformcicioii h c eiiciiciitra en el pizarrón.

0 Las interacciones de expertos tienen lugar a través del pizarrón. el control coinpleto del proceso de problemas a resolver puede determinarse esclusi\.anientt'ite por la orden de los expertos.

Como ya se menciono anteriormente un sistema de pizcirron se piieclc considerar como la unión de uno o más sistemas expertos. Por eso se pcirtiri cic los coiiipoiiciites de un sistema experto único para ejemplificar en diagrama de bloques cc)iiio se da la unión antes mencionada.

DIAGRAMA DE BLOQUES DEL SISTEMA EXPERTO

de Trabajo Inferencia C'oiiociiii lento

Componentes de un Sistema de Pizarrón El modelo de pizarrón abarca cuatro componentes:

0 El pizarrón. 0 Las fuentes de Conocimiento.

Laagenda. 0 El control.

Bases de Dat entes 45

Il -___ -__ __ Sistemas de Pizarrón

t - -- _I--

DIAGRAMA DE BLOQUE S DEL SISTEMA DE PIZ.-\KIIOIV

l U E N T E S DE -I- CONOCIMIENTO

- 1

-/CUENTES DE t

AGENDA I 4

.- - iitCiIblEN

C’ONTROL DE I

Teniendo los diagramas de bloques explicaremos las similitudes eiitre amhns !. conio se da la unión de uno o más sistemas expertos. para formar el sistema de piziirr6n.

Un pizarrón funciona como una memoria de trabajo que archi\ a todos 10s datos para resolver un problema. En un modelo de pizarrón la base de coiiociiiiiciito J e l iiiotor de inferencia pasan a formar la fuente de conocimiento. L a agenda ! el control son módulos que se utilizan en el sistema de pizarrón para controlar o determinar las accicmes de los expertos. Y como en el sistema experto solo se tiene un experto. no h e necesita de la agenda ni del control.

Las fuentes del conocimiento son análogas a los expertos. estás taiiii3it.n abarcan el conocimiento necesario para resolver el problema. Las fuentes de cnnociiiiiento son independientes una de otra, y responden y modifican información en cl pizmOii.

Ahora se explicarán cada una de los componentes del sistema tlc pizm i-0~1 J \e dará el código correspondiente, al final se presentará el programa coiiiplero de 1111 \tbtetiia de pizarrón (experto en fnitas, partiendo del sistema experto que se re\ iso con aiitciioridad). el cual se desarrollo teniendo en mente la idea de que un sistema de pirm-nn puede implementarse a partir de un sistema experto.

Bases de Datos 46

- y-- L -

.@temas de Pizarron

EL PIZARRON

El pizarrón es una base estructurada. a través de la cual las f1ientt.s cit. coiiociiiiiento interactuan para poder procesar el problema a resolver que este registraclo. pizarrón es utilizado por cada fuente de conocimiento, sin embargo la estructurri global clcl iiiismo no se modifica, esto hace posible que cualquier información que este en el pimrr0i i piiecie ser leída y utilizada por las fiientes de conocimiento que las necesite.

Como hemos visto. el pizarrón es un conjunto de bases estriictui.;d;iis cii iiiiii IOrma accesible, para toda la información relevante en el proceso del prohlciiiii ;I rc501~ ci' cliic está registrado. Las fuentes de conocimiento adicionan contenidos en el pirarrOii( siii cambiar su estructura global) como resultado de su razonamiento. y toda coiiiiinicacitin entre las fuentes de conocimiento es a través de el pizarrón.

DESCFUPCION ALGORITMICA DEL PIZARRON

. .. Las funciones del pizarrón están ejemplificadas en la listiiis *-h i ! "iio" del programa experto en frutas. dichas listas guardan las respuestas de los usuarios. tiiiiibién el pizarrón guarda los resultados de los expertos (parciales) J el resultado tina1 que se obtiene al comparar cada una de las opiniones de los expertos.

La función compara(), compara cada uno de los resultados (parciales) de los expertos (guardados en las variables resultado 1 y resultado3 correspondientes a cada experto) para desplegar una conclusión final. La comparación ! el dt.sple_cxlo se hace utilizando el pizarrón.

void compara() i

escribe("\n");

si( resultado 1 [O]=='\xO' && resultado2[0]=='\xO')

otro escribe(" No se ha encontrado algún objeto con esas características"):

si(resultad0 I [O]!='\xO' && resultado2[0]!='\xO')

si(!compara cadena(resuitado I . resultado?. 20) ) /* SI ai comparar In\ i'cwltaclo\ c\toT son I g II J le \

escribe("Los expertos encontraron el objeto VOS", resultado I ).

Bases de Datos In 47

otro i

escribe("E1 experto 1 encontró el objeto Yosh". resultado I ): escribe("E1 experto2 encontró el objeto %s\n". resultado?):

; 1

otro

escribe("E1 experto '?ód encontró el objeto ?'OS". (resultado?[O]==?xO')? I : 2, (resultado2[O]=='\xO')? resultado I : resultado?);

1 1 gotoxy(30.22); escribe("1ntroduzca <ENTER> para regresar al menú"); ;etch(); regresa;

1

La función intenta() pregunta al usuario acerca de los atributos. C'acia cespiiesta afirmativa hace que se adicione el atributo a una lista de atributos conocidos. de lo coiitrario hace que se adicione el atributo a una lista de atributos rechazados. Aquí el LISO del pizarrón se hace solo al guardar las respuestas del usuario ( si , no y p).

int intenta(ATRIBUT0 *p.char *ob) f

char respuesta; ATWBUTO *a.*t;

si( !sigueno(p))

regresa O:

/* verifica que el objeto no tenga ninguno de los atributos que !a Iian sido rechazados * I

si( !siguesi(p))

regresa O;

,'* verifica que los atributos del objeto sean iguales a todos 105 C ~ L W e\pecitica el usuario *

m ¡entras( p) { / * al siguiente atributo * I

* si ya se ha preguntado entonces moverse*

si( preg( p->atrib)) {

escribe("es/ha/'tiene YOS ",p-'atrib); respuesta=tolower(getch()); /* guarda la respuesta en el pizarrón +

escribe( "':n");

Bases d e Datos Inteligent 48

I*>>*/

I*<<*/

a-(ATRIBUTO *)malloc(sizeof( ATRIBUTO)); si(!a) I

escribe("Fuera de rnemoria\n"); salida(0);

} a->siguiente=" O': switch( respuesta) {

caso In': copia cadena(a-~atrib.p-'atrib); si(! no) {

no=a; siguienteno=no;

1 otro {

siguienteno->si~uiente=a; siguienteno=a;

rechaza(ob. p-%trib. Is');

regresa O: caso Is':

copia cadena(a->atrib.p->atrib): si(!si) {

si=a: siguientesi=si:

1 otro {

sigu ientesi->siguiente=a: siguientesi=a;

p=p- -siguiente; break:

razonando( ob): break

\

caso 'p': * por que? *i

1

1

1 otro


p=p-'siguirnte:

regresa( I ): 1

LAS FUENTES DE CONOCIMIENTO

Cada fuente de conocimiento examina el pizarrbn para rcd irni- coiiibiiiacioiies de sus objetos de entrada y así generar nuevas conclusiones. Las fuentes cie conociinieiito. se mantienen responsables del conocimiento y de las condiciones en donde su experiencia puede ser aplicada. Esta información esta dividida generalmente en dos coitiponentes: condiciones y precondiciones.

La separación de condiciones y precondiciones permiten ideiiti ticar las fiieiites de conocimiento que podrían ser apropiadas para contribuir. Porque toda coiiiunicxiOn entre las fuentes de conocimiento esta enviada a través de el pizarrón. L t o pi-mite que la construcción de un sistema completo este instalado en m8dulos separdos. IambiPn supone que el conociniiento del problema a resolver requiere de un bistcina clue piieda estar trabajando independientemente en especialidades diferentes.

Todos los pasos del proceso de solución del problema son explícitos. Esto es importante desde el punto de vista del control, ya que la decisiciii es planeada con base ai estado del problema.

DESCRIPCION ALGORITMICA DE LA FUENTE DE CONOCIMIENTO

Como se menciono anteriormente en un modelo de pizarrón el motor de inferencia y conocimiento (componentes del sistema experto) pasan a ser la ftiente de

antes la base de conocimiento. Entonces se describirán algoritmicamente los dos componentes mencionados.

0 Estructuración de la Base de Conocimiento

typedef struct atributo { char atrib[80]; struct atributo *siguiente;

}ATRIBUTO:

Bases de Datos inteligentes 50

typedef struct objeto { char nornbre[SO]: struct atributo *alista:

] OB JETO :

typedef struct objeto-rechdzado { char nornbre[80], char atrib[SO]. /*atributo que causo rechuzo* char condicion. /*Io necesitaba o no deberla*

{RECHAZADO. *haber sido encontrado*/

0 Motor de inferencia

/* /* '* pregunta() envía a intentaoun objeto cada vez. hasta que, intenta0 '* lo encuentra o bien la base de conocimientos se asota.

/ * % * * * * * + * % * * + * * * + * * ~ * * * * * % * % * * * * * % % * * % * * * * * ~ ~ * * * * * * * * * * ~ * * * * % * * * ~ ~ ~ ~ ~ * * t k *

void pregunta0 { int t; char ch: ATRIBUTO *p;

* L a función más importante del SISTEMA DE PIZARRON es pregunta A

* * i

/* %

para( t=O;t<=ngos;t++) { p=base-c[t].alicta; si( intenta(p.basec[t] .nom bre)) {

copia cadena(resultad0 1 , base-c[t].nombre): regresa;

} otro rechaza(base-c[t].nornbre. p->atrib. 'n'):

Bases de Datos Inteligentes 5 1

int intenta(ATRIBUT0 *p.char *ob) t

char respuesta; ATRIBUTO *a.*t:

si(!si;ueno(p))

regresa O:

* veriticn que el objeto no tenga ninguno de los ,111 i l i r i r o \ cliic \ < I 11m sido rechazados * I

si(!siguesi( p))

regresa O;

* verifica que los atributos del objeto sean iguales ;i toclos 105 C J I I C cywcit ica C I usuario *,

rn ¡entras( p) { /* al siguiente atributo * /

* S I !a se ha preguntado entonces moverse*

si(preg(p->atrib)) {

escribe("esiha, tiene O / O s ".p-'atrib). respuesta=to lo^ er(getch( )). escribe(%").

'* guarda la respuesta en e l p i m I o11

a=(ATRIBUTO * )malioc(sizeof(ATRIBUTO)); si(!a) {

escribe("Fuera de memoriah"): salida( O):

1 a->si;uiente="tO': switch(respuesta) {

caso In': copia cadena(a->atrib.p->atrib): si( !no) f

no=a: si;uienteno=no;

t

otro i siguienteno->si;uiente=a; s i y ienteno=a:

1

rechaza(ob. p->atrib. Y):

regresa O:

*>>*I

/*<<*I


caso Is': copia cadena(a- -.atrib.p-:-atrib):

si(!si) I I

sI=¿l; sigu ientesi =si;

1

I otro

sigLiientesi-)si;uiente=a: siguientesi=a:

1 p=p- >siguiente: break;

razonando(ob); break:

caso 'p': /* por que? *,'

1 1

otro p=p->sigu iente:

} regresa( I );

}

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i* * r !* Comprueba que el ob.jeto no tenga ninguno de los atributos que ya han * /

'* sido rechazados. I* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int sigueno(ATRIBUT0 *p)

* ' * '

ATRIBUTO *a, *t: a=no; mientras(a) {

t=p: m ientras(t) {

si( !compara cadena((->atrib.a->atrib))

t=t->siguiente; regresa !I: i* tiene u n atributo negativo *i

1 a=a->siguiente:

1

7

Bales de Datos Inteligentes 53

regresa I : 1

l****,*******************%***********~***%%************** L I ; * * * * * ~ * * Y X Y %

Í* / * Comprueba que los atributos del objeto sean iguales a todos los qiie * i* especifica el usuario I*

int siguesi(ATRIBUT0 *p)

*

* *

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

{ ATRIBUTO *a,*t; char ok;

a=si; mientras(a) i

ok=O; t=p; m ientras(t) {

si(! compara cadena( t->atrib.a-,atrib)) ok=l;

t=t->siguiente; * no tiene un atributo negativo *:

} si( ! ok)

regresa O; a=a->sigu iente;

1 regresa I ;

l.

/ *****************************************************************~*Y****~*

I* *Í

Í* verifica si el objeto tiene un atributo que ya haya sido preguntado *

/ * * * * * * * * * * * * * * * * * * * * * * * * * % * * * * * * * * * * * * * * * * * * * ~ * * * % * * * * * * * * * * * * * ~ * ~ ~ ~ * ~ ~ ~ ? ~ ~ !* * !

int preg(char *atrib) r

ATRIBUTO *p; p=si: mientras(p && compara cadena(atrib.p->atrib))

p=p->siguiente:


si('p) regresa I ;

regresa O; otro

1

EL CO

,* falso SI es el final de la lista *

lTROL ' LA AGENDA

El modelo de pizarrón incluye. un regimen de control que nioiiitorea al pizarrón y determina que acciones son adecuadas para tomar. Ademis dirige el punto de atención del problema a resolver. que puede ser una fuente de conocimiento. un conjunto de objetos procesados en el pizarrón o una combinación de ambas.

El régimen de control de un sistema de pizarrón puede ser siiiiiiiiistrado por una colección de fiientes de conocimiento que actíian: sobre un pizarrón. o sobre In iiitoriiiación de la agenda y el control.

El régimen de control es el que se encarga de decidir clue acciones son más adecuadas para una decisión en particular. Y la agenda es la que se encarga de decidir que experto interviene en la solución de un problema registrado.

A continuación se presenta el código para implementar estos componentes. tomando como ejemplo el sistema de pizarrón experto en frutas que aquí se desarrollo.

DESCRIPCION ALGORITMICA DE LA AGENDA Y EL CONTROL

La agenda y el control es en este caso l a función ejecuta(). El procedimiento ejecuta() funciona de la siguiente manera. ejecuta() determina que experto interviene primero. En particular para este programa la decisión es deterministic,?. Sicnipre interviene el experto1 primero y en seguida el experto2 Está decisión también puede SCI- aleatoria.

void ejecuta() { char ch; no=si=NULL; haz { libera-lista(); ch=menu(); switch(ch) I

!* menú es un desplegado que te da la opción de preguntar( I ) o snlii-(O) *

Bases de Datos Intefigen 55

- - - - --I .. . - __ ._

. . . .- ._ - - . . . . . . Sistemas de Pizarr6n

. E------ -__-I_-

caso ' i ': ineinseqresultado I . ",xO'. 20 i : memset( resultado:. '\SO'. 20): carga( ): pregunta( ): libera-lista(): carga?( ); pregunta?(): libera-l ¡Sta( ): cornpara( I; break:

1 } rnientras(ch !='O');

}

Ahora se presentara en el apéndice B todo el código del Sistriiin de Pizarrón (experto en frutas), que se desarrollo en este proyecto.

56

#includevonio h' #iiicluderctype h' #includc-:string.hl #include<stdio.h' #includerstdlib.h> #include4loc.h'

#det¡ne MAX 200

/*declaracibn de las estructura de datos*/

typedefstruct atributo char atrih(8üj. struct atributo 'siguiente:

!ATRIBUTO:

typedefstruct objeto{ char nombre[80]: struct atributo *alista.

[OBJETO:

typedef struct objeto-rechazado char nombre[80]: char atrib[80]. char condicion:

I RECHAZADO:

I' kclaracion de las variables globales*/

RECHAZADO r-base(MAS].

OBJETO base-c[MAX]. int ngos=-I; int r g o s - I :

I* mantiene la base de conocimiento\ * localizacion de la cima de la h w *

I* localizacion de la cima de la h.ix dc4 '*rechazo *

Püeclaracion de los prototipos*/

void Iibera-lista(). void introduce(). void pregunta(). void razonando(char *ob); void ini-basec(): int intenta(ATFUBUT0 *p.char *ob);

Bases de Datos Intefigeotes 57

- ___ -~

Apéndice A ---- _ _ _ --I_.

Sistemas Expertos I-

! ~

int ,igueno( $TRIBUTO *pl void rechaza(char *ob char *%it L I I X coiid), ohtiene_~igUiKntK(). char menu(). void salva(), void carga().

void main() I

char ch: no=si=NIJLL: clncr(): gotouy(30.2): cprintf("S1STEMAS EXPERTOS"): do I

libera-iista(); ch=menu(): switch(ch) i

Case '¡I: introduce(): break.

break:

break.

break.

case 'p': pregunta():

case Y: salva():

C ~ S K 'c': carga():

1 )while (ch !='x')

1

void libera-lista()

ATRIBUTO *p:

while($ r I

p=si->siguiente;

si-: 1 while(no)

fiKK(S¡);

t

p= no->siguiente: free( no): no==:

i

I

/*******+*****************8**********************8*********************~***!

/* *i

/* Lee el nombre de un objeto su lista de atributos. para despuis *; /* introducir dicha informncióii en la BASE de CONOCIMIE&TO */ /* *¡

void introduce()

/*t***+tl***tti*t**ttl*t*ff****t*ttftt+f%**********************************!

in1 1: ATRIBUTO *p. lanteriorg:

for(: :) L

FObt¡KnK-S¡gU¡KntK(): i* obtiene el indice del siguiente objeto de la base-c */

58

i igos- - . break:

I

p=(ATRIBUTO *)innlloc(siit.of(~~TRlBUT(>)). if( p=='\o') I I

printf( "Fuera de iiieiii~~ri~i.\,n"): return.

I base-c[tJ.alista=p:

printf("1ntroduce 10s atributo.; (RETLIRN para salir)\n"): for(::) I I

printt~" : "). gets( p->atrib): if (!p->atrib[O])

anteriorg=p: p->si~uients=(r\TRIUC;TO *)iiialloc(sirsof(ATRIBlJT~)). p=p->siyiente. p->si@uiente=NllLL. if( p=NULL )

break:

printt7"Furra de iiirmoria"). return:

I \

anteriorp->siguiente=10'. I

i I*<<<<<< <<<<<c I%íPLE%1ENTACION DEL MOTOR DE 1NFI:'RENCI.A ' . .'. <

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* */ /* /* pregunta0 envia a intenta() un iibjeto cada vez. hasta que. intenta() */ /* lo encuentra o bien l a B.r\SE dr CONOCICMIENTO se agota. I* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

void pregunta()

La función mas importants del SlSTEhlA EXPERTO si pregunta(). *

*;

l

int t; char ch: ATRIBUTO *p. for(t=O:t<=ngns:t++)

p=base-c[t] alista: if(intenta(p.bas~_c[t].nombre))

I I

I I

printti"aas concuerda con la actual descripcion\n".basr._C[r].nombrt.i. printf("continuo" (S:Tu')"): ch= tolo\ver(getch( ) I: printf("in"). if(ch='n')

return: I else


, printtx" Objet«(s) no enciiiitr;ido(s)").

I

/ + t t ~ + + r t 8 8 + + ~ $ + ~ 8 + + + + r + r t * c t * + + r + c t t t r * ~ * $ 8 8 8 * * * $ 8 * * * * * * 8 ~ * * * * 9 * * ~ ~ ~ ~ ~ * ~ ~ * ~

/* *: /* La funciún intenta() contieiie 13 iiiteli@eiicia del SiSTE%íA EXPERTO /* Pregunta al usuario acerca dc los atributos Cada respuota atiriiiativa *í i* hace que se adicione e l atrihiito a u n a l is ta de atrihutos coiicicidos. de * / /* lo contrario hace que se adicioiie e l atrihuto a tina lista de atrihiitos */ /* rechazadoh. * /

/* *i /*************+***************************************?****9***~****~****~*

int intenta(ATRIBUT0 *p.char *oh)

* '

i char respuesta: A T N B U T O *a.*t: if(!sigueno(p)) return O:

return O: whiie(p)

if(!siguesi( p))

I /* al sieuieiite atributo * /

/* si > a se 11a preguntado entonces moverse * I I

if(prep(p->atrib)) I

printf("es/hdtiene " O S ".p->atrib). respuesta=tolo\~er(getcli( )). printf("\n");

a=(ATRíBUTO *~malloc(sizrof(.4TRlBL~T0)). if(!a) ,

printf("Fuera de iiieinoria\n"). exit(0):

I

a->siguiente=fO. switch(respuesta) I I

case h': strcp) (a-,atri b.p->atrib): if( !no) , no=a. siguienteno=no.

1 elst: I u

sipuieiitrno->si_ouiente=a. siguienteno=a:

1

return O. I+ rechazaíob. p->atrib. 'n'):*'

case Y strcpy( a->atrib.p->atrib):

if(!si)

si=a. siguientesi=si:

, , else


1 -1 -

-1 Sistemas Expertos Apéndice ii L-- ___ ____I__- -- -

I #

p=p- ' \ l y l c l l t e break.

razon,iiido(ob) breah

c'L.e 'p' * por que ' *,

i

i else

p=p-'siguiente:

return( I ). I

*/<<<<<t<<tr<~C<~<<~~, _\_ FIINC IONES DEL FXPERTO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . * * /* * /

/* Comprueba que el objeto no tciiga ninguno de 105 atributos que !A han * ' /* ,ido recliazado\ */ I* *i /**************4******************************************************~****

int sigueno(ATRIBUT0 *p) :

ATRlB lJ FO *U. *t. a=no. while(a) I

t=p: while(t) I

if( 'strcmp(t->atrib.ii-'atrib))

t=t->siguiente: return O; * tiene un atributo negativo */

a=a->si y iente:

return 1;

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* *! /* Comprueba que los atributos del objeto sean iguales a todos los que *!

/* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int siguesi(.4TRIBUTO *p)

I* especifica e l usuario * I

I I

ATRiBUTO *a*t: char ok:

a=si; while(a)

0k=O; t-p: while(t) I I

if(!strcmp(t->atrib.a- -atrib)) ok=l. t=t->siguiente:

i* no tiene un auibuto negativo *

1 if( ! ok)

return O: a=a->siguiente:

return 1: I

Bases de Dafos Inteiigentes 61

Sistemas Expertos - --____--

,************f************::********f**********f************f**~******,'***

I* *

* \Critica >I el ohleto tiene t i n .itrihiito que !.I Ii<n .I \ido pre~iiiii.ido '1

f * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int preg(cliar *atrib) I

ATRIBUTO *p:

whilefp && strcmp(atrib.p- x t r ih) ) p=s i :

p=p->siyiente:

i t l i p )

else return I:

return O:

I* falso SI es el tina1 de la lista */

I*<< <<<<<< . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . - * , I* * /

I* Muestra el estado actual del sisteiiia. y tambiiii que objetos han /f I* *¡ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . vo id razonando(char *ob)

FIN DE LA IMPLEMENT.4CION DEI. \1OTOR DE INFERFNC'I!\

*/ sido rechazados y el por que. t '

9

ATRIBUTO * t ; inti;

printf("lntentand0 %s\n".ob).

printf("es/tienelha :\n"): if($

t=si: while(t) I

printt~"?~ós\n".t->atrib): et->siguiente.

itxno)

t=no: while( t)

printf("no esltieneha : h"):

I

printf("o/os\n".t->atrib). t=t->siguiente:

I for( i=O:i<=rgos:i++) I I

printf("Vos rechazado porque ".r-hase[i] nombre): I* if(r-base(i].condicion='n') */

/* else printf("o/os no es un atributo \n".r_base[i].atrib):

printf("%s es un atributo requerido.:n".r-base[¡] atrib). */ I

1

I*>>>>>>>>>>>>>>>>>>>> FIN DE LAS FUNCIONES DEL. EXPERTO <<. /~ . . .:

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

I* 2;

I* Coloca el objeto rechazado en la BASE de DATOS y el atributo que I* causo el rechazo. * I I* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

*:

-- - i ipéndice .4


- - ~ _ _ I

- IpCndire A --__ ---

Sistemas Expertos ~-

\ ~ i d rechaza(char *oh. char *d chJrcoiid) I I

rgos++.

strcpy(r-hase[rpos] nombre oh) strcpy(r-base(rgos] atrih at) r-base[rg«s] condicion=coiid

I

/*****************************************************b*************~*~.,~*

/* * I

/* Obtiene el siyieiite indice Iihre en e l de la hase * I /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . < % * *

int obtiene-siguiente() I

ngos++,

i f (njos<MAX) return ngos:

else return -I ;

1

char menu() I

char ch; printf("\n\n(i)ntroduce.( P)reynia.( S)al*a.(C)arga.e( X)it\n"): do I

printf("e1ige una: "): ch=tolower(getch()):

} while(!ecta-en(ch,"ipscx")).

printf("\n"); return ch;

!

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* */ /* Salva la BASE DE CONOC'ISiIENTO ' I /* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void salva() i

int x.t: ATRIBUTO *p: FILE *fp:

if(( fp=fopen( "experto.dat"."\\ ")t==O) I

printf("No puedo abrir e l archivo\n"): return;

I I

printf("sa1vando base de conocimientos'n" 1:

for(t=O:t<=ngos;t++) I

for(x=O:x<sizeof(base-c[t] nombre):x++)

p=base-c[t].alista: while(p)

putc(base-c[t].nomhre[u]. fp):

I I

for(x=0:x<sizeof(p-,atrib):xt+) putc(p->atrib[x].fpi:

Bas& de Datos Infagentes 63

i int t x ; ATRIBUTO *p. *anterior-p. FILE *fp; if(( fp=fopen( "exprrto.dat"."r"))==0) i

printf("no puedo abrir el arcliivo\n"). return;

i printf("cargando la base de c«iiocimientos\n").

/* libera una lista anterior *i ini-basec();

for(t=O;t<MAX:++t) í if((base_c[t].nombre[O]=getc( fp))==O)

break.

for(x= I ;x<sizeof(base_c[t].nombre):x++) base-c[t].nombre[u]=getc(fp):

base_c[t].alista=(ATRIBUTO *)malloc(sizrof(.L\TRlB~TO)).

if(lbase-c[t] alista) I

printf("fuera de inenioria\n"): break;

I

base_c[t].alista=(ATRIBUTO *)malIoc(sizrof(i\TRIBL'TO)). p=base-c[tJ.ai ista:

printf("fuera de memoria"): return:

for(x=O:x<sizeot(p- ,atrib):x++) p->atrib[s]=getc~fp).

if( !p->atrib[O]) I

anteriorg->siguirnte=90': break: i* tin de la lista * /

1

p->siguiente=( ATRIBUTO *)malloc(sizeof(ATR1BC10));

Bases de Dafos fnteligentes 64

F ____--

Sistemas EX&& -

____--__I-- --I_ --

I

a11 terior-p=p. p=p->siguiente.

I i fclosr(fp):

iigos=t-I: I

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . i . r l l t

I* * I /* Inicializa la BASE dc C'ONOClhllENTO *I /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void ini-basec() I l

int t; ATRl BUT0 * p. * p2:

for(t=O: t<=ngos: t++)

i p=base-c[t].alista:

while(p) t

p2=p: free(p): p=p2-~iguiente,

I I

i int esta-en(ch.s)

char ch. *s: *

while( *s) if(ch=*s++)

return I : return O;

I

Basa de Datos Inteligentes 65

___._--__ ---- --_I__

.- ___ .__-. - 1 Sistemas de Pizarrón

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

i * IJn SISTEMA de PI/ IRRON que riicuriitrn nieta\ C i

-

i

$

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

#include<conio h> #include<ctype h> #include<string h> #include<stdio h z #include<stdlib h> #include<alloc h>

#detine MAX 200

/* <<<<<<<<<<< Declaracih de Ins estructuras de datos < c ~ . .-. i<<<<<<i.: ...*~

typedefstruct atributo; char atrib(X01. struct atributo 'siguiente:

!ATRIBUTO:

typedef struct objeto: char nombre[80). struct atributo *alista.

)OBJETO:

typedefstruct objeto-rechazado char nombre[80]: char atrib[80]: !*atributo que causo rechazo*! cl iar condicion: '*lo necesitaba o no debería */

:RECHAZADO: /*haber sido encontrado*/

RECHAZADO r-base[MAX]

OBJETO basec[MAX]. int n g o s = - I , int rgos-I .

/*mantiene la base de conocimiento,*/ i'localizacion de la cima de la base*

/*locaIizacion de la cima de l a base de* *rechazo */

ATRIBUTO *si. *no. 'siguienteno. *siguienresi. char resultado I IZO]: char resulrado2[20];

/*<<<<<<<<<<<<<<<

void main(void): char menu_g(void): char menu-exp(void): /+Despliega el No. de los expertos. > guarda*/

char menu-instru(void): /*Menú de instrucciones*/

Declaración de 10s prototipos <<<<<cii <<<<<<i<c <. . . *

/*Menú general del prob-grama*/

/*el elegido*/

I

Bases de patos infeligeates 66

-_ _- __l__l_____- -- I Sistemas de Pizarrón

void ieuto(void): void Iihera-lista(void): ' I ihcra menioria*: void ini-baiec(void): void introduce(void):

void ejecuta(void): void intro-eup(void).

void compara(void):

int intenta(ATRIBUT0 *p.cliar *ob)./*Los atribiitoi atirmados por e l usuario'!

* i c \ i o de iiis instrucciones*!

* l i i i c i d i ~ a la b a r dc coniciniieiito" /*L cc e l iiuiiihre de uti ohicto y sus atrihiitils para'

.'*intrcducirlos en la hasc de conocinlieilto* / *h tc r i i i i i i a que experto interviene primero*/ í*C'oinp:ira que experto \e iiitroduio para iiainar*/

i*C'oinp:iriI Ins conclusiones de los r\penos para*/ P a las funciones ciirrcspiindientes*:

:*elegir Icl mas optima*/

i*intenta()los adiciona a una lista de*. /*atributos conocidos. de lo contriir¡(\ I t ) , -

/*adiciona a una lista de rech;izados* int obtiene_siguiente(void~. *Ohticiie el siguiente indice libre en*/

!+el array de la base*# void rechaza(char *ob. char *at. char cond): /*El ob.jeto rechazado y el*/

i'atrihiito que causo el recIia/o /*es colocado en la base'! /*de datos+/

int esta-eii(char ch. char *si:

/* FUNCIONES DEL EXPERTO I */ void pregunta(char experto): ,*Pregunta0 eni ia a intenta() un ob.jeto cada*/

Í*\ez. hasta que lo encuentra o la base de+ /*conocimiento se agota*/

void carga(char experto); void salva(char experto): int sigueno(ATRIBUT0 *p). , 'Veritica el objeto no tenga ninguiio de los*/

int siguesi(ATRIBUT0 *pi. ,*Verifica que todos los atributos sean iguales*/

int preg(char *atrib):

void razonando(char *ob);

'*Carga la base de conocimiento*/ í *Sa l \a l a base de conocimiento*/

/*atributos que ha'an sido rechazados*

P a todos los que afirma el usuario*/

/*atributo que ya haya sido preguntado*,

/*! e l por que*/

PVerit ica que el objeto no tenga ningún*/

'*5luestra que objetos ) a han sido rechnzados*/

/* FUNCIONES DEL EXPERTO 2 *i void preguntai(char experto).'*Pregunta(1 envia a intenta() un objeto cada'i

/*vez. hasta que lo encuentra o la base dc' /*conocimiento se agota*/

void carga2(char experto): void salvd(char experto); int siguenoZ(ATRIBUT0 *p): *Verifica e l objeto no tenga ninguno de los*/

int siguesi2(ATRIBUTO *p) : *Verifica que todos los atributos sean iguales*/

int preg2(char *atrib):

void razonando2(char *ob).

int intentaZ(ATRIBUT0 *p.cliar +ob):/*Los atributos afirmados por e l usuario*

*Carea la base de conocimiento*/ 'Saha l a base de conocimiento*;

/*atributos que hayan sido rechazados*

/*a todos los que afirma el usuario';

í'atrihuto que ya haya sido preguntado'

/*! el por que*/

PVeritica que el objeto no tenga ningun*/

'~ luestra que objetos )a han sido rechazados*!

/*intenta()los adiciona a una lista de* /*atributos conocidos. de lo contrario l ~ i \ ~ /*adiciona a una lista de recharadoh*

Bases de Datos Intelígentes 67

I

char opcion:

clrscr( ):

do ' I

opcion = menu-g(): su itch(opcion) I

' 1 ' : menu-instrii( ). break.

case '2': intro-exp( ). break:

case '3'. ejecuta(): break:

¡ )while (opcion !='O): clrscr().

!

char menu-p(void) t

char ch:

clrscr(); gotoxy(25. I ) : printf(" Éiiíiiiiiiíiiiiiiiiíii>,*<). gotoxy(25. 2): printf(" o ""1: potosy(25. 3);

printf(" o "Y: gotoxy(25. 5 ) ; printf(" Eiiiiiíiiiiiiiiiiiiiii~ .").

gotoxy(25. 7): printtl" [ I ] . Instrucciones "). porou?(25. 9): printf(" [2]. Agregar information "): gotoxy(25. I I ) : printtl" [ 3 ] . Ejecutar "); gotoxy(25. 13): printf(" [O]. Salir "): do

printft" SISTEMA DE PIZARRON ""). gotosy(25. 4):

I

gotoxy(3j. IS). printf("elige una: "). ch=getch():

i while('rsta-en(ch."O 123")).

return ch:

void intro-exp(void) I 1

char q e x p :

FILE 'fp:


- - --____ 1 Sistemas de Pmirrón - - I__---- - - - -_- ._

di,

--.-____ 1 Sistemas de Pmirrón - - -_- ._ I__---- -.--_

i )while (q_exp!='O'):

char menu-exp(void) r

char ch:

clrscr(): gotoxy(25. I ) : printf(" Éi i i i i i i i i i í i i i i i i i i i i~~~. gotoxy(25.2):

gotoxy(25.3): printt]" AGREGAR INFORMACION "y gotoxy(25.4): printf(" 01-

gotoxy(25, 5): printf(" Eiíiiiiiiiiiiíiiiiiiii %y

printf(" o "'7:

):

gotoxy(25, 7): printf(" [ I ] . Experto 1 "). gotoxy(25, 9): printf(" 121. Experto 2 "). gotOxy(25. I I ) : printf(" [O]. Salir "): do I gotoxy(35. 15); printf("e1ige una: "); ch=getch():

Iwhile(!esta-en(ch."Ol2")).

return ch: t #

char menu-instru(void) I I

char ch:

clrscr(). gotoxy(25. I ) : printf(" Éiiiiiiiiiiiiiiiiiiiii~,,,). gotoXy(25.2): printf(" O'' ) : gotoxy(25. 3);


t

gotouy(3c.25). printf("sa1ir . "), ch=getch():

) while(!esta-en( ch,"O")).

return ch: I

void texto() I

gotoxy( 10.7); printf("Este programa es un SIS TEhlA de PIZARRON expeno til frutas"): gotoxy(8. IO): printf("E1 sisteiiia tiene dos t.\pertos los c~iales contienen diferente"): printf(" información"): gotoxy(2. I 1); printf("para distinguir cualquier tipo de fruta El funcionamiento del "): printf("sistema consiste"): gotoxy(2.12); printf("en hacer preguntas al usuario. este ultimo responde con una 's"'): printf(" que equivale a"). gotoxy(2.13); printf ("una respuesta afirmativa > con una '11' para ne_oarla. "). gotoxy(8.i 5); printf("A1 final el sistema dejplie.ga un resultado. este resultado es"): printtl" el nonibre"): gotoxy(2.16); printf(" de la fruta que enconrrii en base a las respuestas del usuario."):

I

char menu(void) I I

char ch;

clrscr(): gotoxy(25. I) : printf(" Éiiiiiiiiiiiiiiiiiiiii,,y gotoxy(25. 2): printfi" O"):

gOtouy(25. 3). printf(" E J E C U T A "").

gOtoxy(2c. 4). printf(" * "'7: gotoxy(25. 5 ) ; printfi" Eiiiíiiiiiiiiiiiiiiiiil.j..,.

gotoxy(25. 8): printtl" [ I ] . Pregunta ' I ) :

gotoxy(25. IO). printf(" [O]. Salir "): do I

gotoxy(35. I S ) : printf("elige una: "):


ch=getch( ): ~while(!esta-en(ch."O I ")).

printtl"\n"): return ch:

t

b o i d libera-lista()

ATRIBUTO *p:

while(si)

I

I

p=si->siguiente: free( s i ). si=p.

1 while( no) I t

p= no->siguiente: free(no): no=p.

i

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * I I* Lee el nombre de un objeto su lista de atributos. para despues *í I* introducir dicha informacion en la base de conocimiento 'I I* *: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void introduce() I

int t: A T N B U T O 'p. 'anterior-p.

I*>>>>>>*/ clrscr():

I*<<<<<<*/ for( ::) ;

t=obtiene_siguiente(): obtiene el indice del siguiente ohjeto de la base-c *I

if(t==-l) i

printf("fuera del espacio de l a lista.\n"). return:

I prinif("Nombre del ohjetn "). gets( base-c(t].nombre):

if(! *base-c[t].nombre)

ngos--: break:

I

1

p=(ATRIBUTO *)rnalloc( sizeof(ATRiBUT0)): if(p=?o') I


0

hiise-c[t].alista=p. printf("1ntroduce los atrihiiiob (RET[ [RN pnr;i salir)\n"): for(:.)

printf(" ' "): gets(p->atrih): i f ( !p-,atrib(O])

anteriorg=p: p->sigiiiente=(A 1 RII\I [TO *~nialloc(si~e»f(ATRIDIiTO)): p=p->siguiente: p->siguieiite=N\ 1I.L. if(p==NULL)

break;

printf("Fuera dc iiiciiioria"). return:

I

I anter iorg-xi guiente='\O':

I

I

/*<<<<<<<<<<<<<<<<<<<.<.. . .,.;.:<<í ,4GEN[),4 <~x<<<.~<~.~<<<i i i<c : . I* */ I* La AGENDA es un componente del SISTEMA de PIZ.4RRON su ftinción cz 1;i v .

I* de controlar que experto iiiteniene primero Para este caso en * I I* particular el control es dcteriiiiiiado. por que inten iene primero el * / I* experto 1 (puede cambiar) L.a ACiEND.4 es la función ejecuta( ). /* * I . . . . . . . . . . . . . . . . . . . . . . . . . -~(<<<CCCi<<>~.>r>>'>,'>, .>>>>>>>>'...' void ejecuta()

*Í

. .

I

char ch: no=si=NULL;

do I

libera-I ¡Sta(); ch=rnenu(): switch(ch) i

case'¡': niemset(rrsuItado1. "YO'. 20). memsei(resultado7. ''~0'. 10): carga( ): pregunta( 1: libera-lista( ): carpa3). pregunta7( ). I i bera-1 ¡Sta( ): compara( ): break.

}while (ch !='O'):

/*<<<<<<<<<<<<<<<<<<<<<* < FIN DE LA AGENDA i., ,,>>>>>>, ,

Bases de Datos lnteligeotes 72

I

int t: char ch: ATRIBUTO 'p.

if(experto=='I') i

clrscr0: printf("\n\n\n"):

t

p=base-c[t].alista: it(intenta(p.base_c[t].no~nhre)) ...

if(experto='l')

else

return.

strcp~(resultado1. bnse-c[t] nombre).

strcpy(resultado2. base-c[t] nombre).

I else

rechaza(basec[t] nombre. p->atrib. 'n').

. . . . . . . . . . . . . . . . . . . . . . . . . . PIZARRON >>>>>>>>>>y-->>>>)>>, %

I* *I i* El PIZARRON es otra parte del SISTEMA de PIZARRON su tuncion es l a I* de guardar las respuestas del usuario ( en las listas "SI" y "no"). * I

I* los resultados de los expertos I* I* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

*

el resultado final que he obtiene */ al comparar cada una de las opiniones de loi expertos * /

/*+*r8**t**trt***t***t*LI+*t+l,tl***tS.*****8**********~***~**~**~~*~b*~~*~~

I* *I I* La función compara(). compara los resultados. de cada uno de los *i I* expertos. para así llegar a una conclusión y dar el resultado mas */

I* * / . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . io id compara()

I* optimo */

,

print f( "\n"):

if( resultadol [O]=?xO && resultadoZ[0]=7xO')

else I

printf(" No se ha encontrado algún objeto con esas caracteristicas"):

itlresultado I [O]!=?xO' && resultado2[0]!='\xO') L

if(!strncmp(resuitadol. resuitado2. 20) ) printf("Los expertos encontraron el ohjeto %s". resultadol 1:

e Datos inteligentes 73

~

f Siseenas de Pizarrón - _____I-___~

else I

printf("El experto I encontró el ohjetn " ~ i u i " . rosultadi>I I : printf("E1 experto? eiicontr6 el ohjetii "dn". resultado?).

I

I else I printf("E1 experto %d enciiritr« el objeto oo.\".

(resultado2[01=='\,\0')'' I . 7. (resultado?(Ol=='\\O')'! resultado I resiiltcido?).

, gotoxy(30.22). printf("1ntroduzca <ENTER:. para resresar a1 menu"). =etch( ); return:

i

i char respuesta; ATRIBUTO *a.*t:

if(!sigueno( p)) return O:

return O: if(!siguesi(p))

while(p) /* si 1 a se Iia preguntado entonces nio\erse *i I /* al siguiente atributo *i

if(preg(p->atrib)) í

printf("esíha/tiene '?O> ".p->atrib). respuesta=tolo\\erl_octch()), printf( "b"):

a=(ATRIBUTO * )iiialloc(sizeof(ATRIBUTO)). if(!a) I

printf("Fuera de rnrrnoria\n"). euit(0):

I

a->siguiente='W. switch(respuesta) I I

case 'n'. strcp! (a- .atrih.p->atrih): if( ! no) I

no=a: sigtiienteno=no:

I else


/*>>*I

/*<<*/

return 0.

strcp? (a--atrih.p->atrih): if(!si)

case 'sf:

I

si=x siguientesi=si:

I

else I

si~tiirntrsi->si~uirntr=a: sigtiientesi=a:

I

p=p->siguiente: break:

razonaiid«(ob): break:

case 'p': j* por que'? * I

1 else

p=p->siguiente; 1 return( I ) ;

I

/*<<<<<<<<<<<<<<<<<<<<\ FLYCIONES DEL EXPERTO I >>>>>>, %' -,

I* *I I* El EXPERTO es otro componente del SISTEMA de PIZARRON su tuncion e5 * /* la de encontrar la solucion rn 5 optima dentro de una rea especifica */ I* en este caso se encontraria una truta en base a la', respuestas que */ I* el usuario dio * I I* *I

/*<<<<<<<<<<<<<<<<<<<~'<<~<<<<<<<<<<~>>>>~>>>~~>->~>>>~>>>~ * ,

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * I I* Comprueba que el objeto no ten_oa ninguno de los atributos que )a han *i

I* sido rechazados *I I* *I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int sigueno(ATRIBUT0 *p) I

ATRIBUTO *a. *t. a=no . while(a)

t=p. while([)

I

I

Bas&"& Datos inteligentes 75

-~ -____

- _ 1 _Wemas de P i z a r r ó r - _

if('strcrnp(t->atrib d- d t r ih ) )

t=t- 'siguiente. return O. * ticiie un atributo negatibii * /

a=a->siguiente:

return I: t

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* */ I* Comprueba que los atributos del ohjet« sean i,tiaies n todos I«s qiic */ I* rspecitica el usuario. *! I* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int siguesi(ATRiBUT0 *p) I

ATRIBUTO *a.*t; char ok:

a=si; while(a) !

ok=O: t=p; while(t) I I

if(!strcmp( t->atrib.a->atrib)) ok=l:

t=t->siguiente; i if( ! ok)

return O; a=a->siguiente;

I return I :

1

i* no tiene un atributo negativo */

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* */ /* verifica si el objeto tiene u n atributo que ya haya sido preguntado *I I* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int preg(char 'atrib)

ATRIBUTO *p: p s i ; while(p && sucrnp(atrib.p->atrib))

I I

p==->siguiente;

if(!P) return 1:

return O:

/* falso si es el final de la l ista */ else

1

/*********************************************************************~L~.*

I* *! /* Muestra el estado actual del bistema. y tanihien que objetos han I* sido rechazados y el por que * I I* */ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void razonando(char *ob)

* I

Apéndice B_]

B l u ~ de Dat ot 76

_____ --___ _l_l - i!%&emas de Proarrón

I I

ATRIBUTO *t int I .

printt1"lntentando %s\n".ob) if(%)

printf("es/tiene/ha \n"). t=si, whiie(t)

printf("%s\n".t->atrib): t=t->siguiente:

I if(n0)

t=no; whiie(t)

printf("no es/tiene/ha . \n").

I

printf("%s\n".t->atrib); t=t->siguiente:

l. for( i=O;i<=rgos:i++) i

printf("%s rechazado porque ".r-base[i].nombre): if(r-base[i].condicion='n')

else printf("%s no es tin iitribut».\n".r-base[i].atrib):

printt~"%s es un atributo requerido.\n".r_base[¡].atrib): i

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* * I /* Coloca el objeto rechazado en 13 base de datos 4 el atributo que */ /* causo el rechazo '/ /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void rechaza(char *ob. char *at . char cond) :

r p s + + .

strcpy(r-basc[rgos].nombrr.oh). strcpy(r-base[rgos] atrib.at ). r-base[rgos].condicion=c»nd.

1

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * / /* /* . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

int obtiene-siguiente()

Obtiene el siguiente indicr libre en el ama) de la base */

, ngos++.

i f (ngos<MAX) return ngos.

else return - I ;

de Dat* InfFIigentes 77

- _____ ______ ._

,Sistemas de Pbpr6n

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* *I /* Salva la base de conocimientos * I /* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void salva(char experto) a

int x.1: ATRIBUTO *p: FILE *fp:

i tt(fp=fopen( "experto I .dat"."w"))==O) I

printf("No puedo abrir el archivo\n"): return;

printf("salvand0 base de c»iiocimirntos\ii"):

for(t=O;t<=ngos:t++) I I

for(x=O:x<sizeof(basec[tI tioinbre):x++)

p=base-c[t].al ista; whiie(p)

putc(base_c[t].nombre[u].fp):

I

for(x=O;x<sizeof(p-)atrib):x++) putc(p->atrib(x].fp).

p=p->S¡gU¡tXltK: 1 I* tin del marcador la lista * I for(x=O:x<sizeot~p->atrib):s+t)

putc(70'.fp);

putc(0.fp); fClOSK(fp):

I

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* *I I* Carga la base de conocimientos *I I* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void carga(char experto)

int t=O.x=O. existe=I; ATRIBUTO 'p. 'anteriorg: FILE * fp:

if(( t.p-fopen("expert0 I .dai"."r"))=O)

I

I

pflntf("no puedo abrir el archivo\n"): return:

I else

KXiStK = 0; !

I* libera una lista anterior*/

¡f(KX¡StK) I

ini-basec():

for(t=O;t<MAX;+tt)

78

~-

._ Sirtemas de Pizarrón

I i f ( ( base-c[tl nornbre[OI=getc( tp))=O)

break.

for(x= I :xq-sizeof( base-c[t].nombre).s ++) base_c[t].nombrrru)=getc(fp).

base-c[tl.alista=(A rRlBUTO *)malloc(si~cof(ATR[DIITO)):

if(! base-c[t].alista) I

printf("fuera de niemoriah"): break:

I

base-c[t].alista=(ATRIBI!TO *)iiialloc(sizeot'(ATRIB~ITO)): p=base-c[t].alista; if('p) I

printf("fuera de memoria"): return:

1 for(: :) I

for(x=O;x<sizeof(p->atrib):xc+) p->atrib[x]=getc( fp).

if( !p->atrib[O]) I I

anterior-p-'si~uiente=~O'. break: /* tin de la lista */

I

p->ciguiente=(ATRIBUTO *)malloc(sizeof(ATRIBUTO));

if(! p->siguiente) I

printf("fuera dr memoriah"); break;

I anterior>=: p=p->siguienie.

I I

I fclose( fp); ngos=t- I :

I

/****************************************s********s************************

I* * I I* Inicializa la base de conocimiento * I I* /***********s***********s****************************************s**s*****~

void in¡-basec(void) I l

int t; ATRIBUTO *p.*p2;

for(t=O;t<=ngos:t++) I

p=base-c[t].alista;

while(p) !

79

p2=p: tiee(pf. p=p2-~iguiente:

int esta-eii(char ch. char *si I

while(*s) if(ch==*s++)

return I : return O:

I

/*<<<<<<<<<<<<<<<<<<<<< FUNC [ONES DEL EXPERTO 7 ,>>>>>> ’> %

I* *I I* El EXPERTO es otro componente del SISTEMA de PIZARRON su tuncion e> * I* la de encontrar la solucion mas optima dentro de una area sspecitica *i I* en este caso SK encontraria una truta en base a las respuestas que * I I* el usuario dio * I I* */ /*<<<<<<<<<<<<<<<<<<<~~.<<<<<<<<<<<<>>>>>>>>>~~,,>>>>>>~,,>

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * I I* Comprueba que el objeto no tenga ninguno de los atributos que >a han * I I* sido rechazados *I I* *I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int siguenoZ(ATRiBUT0 *p) I I

ATRIBUTO *a. *I, a=no: while(a) I

t=p, while(t) I

if(!strcmp( 1->atrib.a->atrib))

t=t->siguiente; return O: /* tiene un atributo negativo */

I a=a->siguiente:

I return I :

\

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * I /* Comprueba que los atributos del objeto sean iguales a todos los que *I I* especifica el usuario. I* * I

int siguesi2(ATRIBUTO *p) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

I I

ATFUBUTO *a.*t: char ok;

a=si:

Bases de Datos 80

I_---

whiic(a) i ok=O; c-p ; while([) :

if(lstrcmp(t- ,atri b.a- -atrib)) ok= 1. t=t->siguiente:

!* no tiene tin atributo nezativo * I

I if( ! o k )

return O: a=a->siguiente:

i return I :

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* */ /* Verifica si e l objeto tiene un atributo que qa h q a sido preguniado *I /* *I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int preg2(char *atrib)

ATRIBUTO *p.

while(p && strcmp(atrib.p->atrib))

I t

p=si;

p=p->siguiente:

if(!p) return I :

return O:

/* falso si es el final de la lista *I else

I

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * I /* Muestra el estado actual del sistema y también que objetos han I* sido rechazados y el porqué. *I I* *I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void razonando2(char *ob) I ATRIBUTO *t: int i :

*/

printf("1ntentando %\n",ob): if(si)

printf("es/tiene/ha :\n"); p s i ; while([) I I

prinif("%s\n".t->atrib): 1st->siguiente:

I if(no)

t=no; while(t) I

printf("no esftienelha : \n"):

printf("%\n".t->atrib): t=t->siguiente:

I for(i=O;i<=rgos:i++)

Bases de Datos I 81

, L

printR"%s rechazado porqiic " r-h&e[i I nombre) itlr-bae[i] c»ndicion='n )

else printt]"o& no eb u11 .itributo \n".r-base[i] rltrib).

printtl"ob> es un ntrihuio requerido \n" r-baselil ntrib) t

if(!sigueno2( p))

if(!siguesi2(p)) return O:

return O ,

while(p) /* s i ya se ha preguntado entonces moverse */ # /* al siguiente atributo */

if(preg2(p->atrib)) i

printf("es/haitiene " O S ".p->atrib); respuesta=toiower(getch()); printtl"\n"):

a=IATRIBUTO *)malloc(sizeof(ATRIBUTO)): if(!a) I I

printf("Fuera de memoriah"): euit(0):

a->siguiente=lO': switch(respuesta) I

case 'n' strcp) (a-)atrib.p->atrib): if( ino) I

no=a sigu ienteno=no,

I else I I

siguientrno->sijuiente=a. siguienteno=a.

I I*>>*/

ses de Datos In 82

I*<<.!

case Is':

case 'p':

return O:

strcpF(a- -3trib.p-zitrib): if(! s I )

, else 1 I

sitiiiciitcsi->siguiente=n. siguiciitcsi=a:

p=p-'s ig 11 ¡en te; break.

razonando2( ob); break.

I I

I* por que? * I

1 i

else p=p->siguiente:

1 return( I );

1

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . /* * I /* La función m s importante del SISTEMA de PIZARRON es pregunta. /* pregunta20 envia a intentaoiin objeto cada vez. hasta que. iiitenta2() */

/* *I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void pregunta2(char experto)

*/

J* to encuentra o bien la base de conocimientos se agota. * I

l

int t ; char ch; ATRiBUTO *p;

i f(experto='2') I

clrscr(); printf("\n\n\n");

1 for(t=O;t<=ngos;t+)

p=base-c[t].alista: if(intenta2(p.base-c[tj.nombre)) I

I I

if(experto='l')

else

return;

strcpy(resu1tado I. hase-c[t].nombre):

strcpy(resultado2. hase-c[t].nombre);

I else rechaza(base-c[t].nombre. p-atrib. In*);

t 1

-.de Datos Inteligentes 83

************~************tftttlt***

I* " I I* Salva la base de ciwocimientos * I I* *I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void salv,Q(char experto) i

int x.t; ATRIBUTO *p; FILE *fp:

if(( fp=fopen("expertoZ.dal"."\~ "))==O) I I

printf("No puedo abrir el nrcliivo\n"); return;

: printf("sa1vando base de CoiioCiinirntos\n"):

for(t=O;t<=ngos:t++) I

for( x=O:x<sizeof( base-c[ I ].iioiiibre);x++)

p=base-c[t].alista: while(p)

putc(base_c[t].nombre~x].~p);

I

for(x=O:x<s¡zeot'(p-'.ntr¡h)~x++) putc(p->atrib[s]. fp).

p=p->siguiente: 3 I* tin del marcador la lista */

for(x=O:x<sizeof(p->atrib).x++) putc(l0:fp).

I

putc(0.fp); fclose(fp);

I

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . I* * I

I* * I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . void cargai(char experto) !

int t=O.x=O. cxiste=l; ATRiBUTO *p. 'anteriorg. FILE *fp:

if((fp=fopen("experto2.dat"."r"))=O)

I* Carga la base de conocimientos * I

i printf("no puedo abrir el archivo\n"); return:

1 else

existe = O ;

I

Bas 84

0 C.J. Date. “ Bases de Datos‘’ De. Addison Wesley Iberoamericana S.A.

0 James L. Noyes. “ Artificial Intelligence with Common Lisp” Ed. D.C. Heat.

0 Janet Kolodner “ Case-Based-Reasoning” Ed. Morgan Kaufmann publishers. Inc.

0 “Neural Networks” De. Chapman & Hall .

0 Haykin, Simon “ Neural Networks. A.”

0 Goldenthal Nathan “Expert systems and AI”

Basca de I&ah Inteligentes 85

universidad autonoma metropolitana …148.206.53.84/tesiuami/uam5588.pdf · este trabajo tiene como...

Documents