cbl148.206.53.84/tesiuami/uam8561.pdf · 1.4.- desarrollo de un sistema experto - adquisición de...

~~

Universidad Autónoma Metropolitana Unidad lztapalapa

'CBL \ < ,

p,, :\ '. ,, ,/

, ,'

// ;' 7'

9". .

Proyecto de Investigación II

A e r f a z entre Lenguaje Natural. ,~ ~

y Máquina de Inferencia.

i 1 , x

Licenciatura en Computación.

Integrantes:

JArredondo Pérez Beatriz - / / J

Rojas Galindo Minerva 1rh3' .-I L "

I N D I C E G E N E R A L

lntroduccion a sistemas Expertos y Lenguajes Natural ............................................... 3

Manual de Usuario ................................................ 15

Manual Técnico ..................................................... 25

Conclusiones .......................................................... 56

Bibliografía ............................................................. 59

Introducción a Y

Sistemas Expertos Lenguaje Natural

lndice general

1.- SISTEMAS EXPERTOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1 . 1 .. Definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.2.- Estructura de un Sistema Experto ................................................................................ 6

1.3.- Esquema de un Sistema Experto ................................................................................. 6

1.4.- Desarrollo de un Sistema Experto ................................................................................ 7

1.5.- Tipos de Sistemas Expertos ......................................................................................... 7

1.6.- Ejemplos de Sistemas Expertos ................................................................................... 7

1.7.- Métodos de Representación de Conocimientos ........................................................... 8

2.- LENGUAJE NATURAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.1 .- Definición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.2.- Características del Lenguaje Natural ........................................................................... 9

2.3.- Forma de Representación de Conocimientos ............................................................ 10

2.4.- Notación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.5.- Interface de Lenguaje Natural .................................................................................... 13

1 .- SISTEMAS EXPERTOS

El término de Inteligencia Artificial comenzó a manejarse desde 1950 , al cual se le daba el significado de Simular o representar procesos humanos como son el conocimiento , los pensamientos, la capacidad de “aprender”, etc.

Las áreas en las cuales podemos dividir la Inteligencia Artificial son:

- Lenguaje Natural. - Robótica. - Planeación y Resolución de problemas. - Sistemas Expertos.

El Lenguaje Natural .-

Consta del desarrollo del proceso de comunicación entre la máquina y el ser humano para entablar una comunicación entre ellos, ya que el lenguaje que entiende la máquina tiene una estructura muy rígida y el del ser humano no.

Robótica .-

Es la parte más desarrollada de la Inteligencia Artificial, principalmente en el área de visión. Consta del desarrollo de reconocimiento de patrones, voces, formas, etc.

Planeación y Resolución de problemas .-

En este caso se presentan esquemas de algún problema y se trata de seguir una lógica para resolver- los.

Sistemas Expertos.

Los Sistemas Expertos se desarrollaron apartir de la década de los 60’s , en aplicaciones como las ciencias, medicina, ingeniería civil, química, bioquímica, etc.

Sus características principales son:

- Ayuda para resolver problemas que requieren de conocimientos de un experto humano. - Herramientas de apoyo en la toma de decisiones.

1 .I .- Definición

Un Sistema Experto consta de uno o varios programas de cdmputo cuyo objetivo es resolver problemas de una área específica del conocimiento de la misma manera que lo haría un experto humano.

Se basan en la manipulación del conocimiento. Contiene “expertize” (expertez o capacidad de decisión) humana por medio de la emulación del razonamiento del experto por medio de técnicas específicas.

Una de las características importantes de los S.E. es la inferencia que realizan (la inferencia es obtener

5

información de la base de conocimientos).

La máquina de inferencias es un conjunto de programas que requiere mucha memoria .

Los Tipos de Conocimientos que se pueden representar en un base de conocimientos para un Sistema Experto son:

- Conocimiento formal (hechos) .- Es el conocimiento general de un campo.

- Conocimiento informal ( heurística) .- Es el conocimiento que se adquiere através de la práctica en un campo específico.

Debemos considerar que si contamos con mayor cantidad y calidad de conocimientos obtendremos mayor exactitud y precisión en las respuestas.

1.2.- Estructura de un Sistema Experto

- Base de conocimientos. Hechos Heurística

- Máquina de inferencias (Estructura de Control). En el mejor de los casos se tiene una interfaz de lenguaje natural muy desarrollado.

- Por lo regular un Sistema Experto hace preguntas y busca alternativas para resolver un problema.

1.3.- Esquema de un Sistema Experto

x p t t r t o - Dominio

r----"--- 1 I

Interfaz

- Usuario

- Máquina de Inferencia

Codificación Base de Experiencia - t i de trabajo

Área de almacenamiento Conocimientos

6

1.4.- Desarrollo de un Sistema Experto

- Adquisición de conocimientos.

- Representación de conocimientos.

- Máquina de inferencias (tipo de razonamiento, por lo regular son de tipo reglas).

- Métodos de búsqueda (puede realizarse considerando la probabilidad ).

- Diálogo con el usuario.

- Explicación al usuario de que reglas se instanciaron.

1.5.- Tipos de Sistemas Expertos

- Entrenamiento

Por ejemplo, entrenar a personal para el manejo de maquinaria industrial resolviendo las dudas que surgen en su manejo.

- Diagnóstico

Se ha desarrollado principalmente en el área de la medicina, en fallas mecánicas, etc.

- Ayuda en la toma de decisiones.

- Resoluci6n de problemas.

En el caso de sistemas expertos de diagnóstico, toma de decisiones o resolución de problemas pueden tener la capacidad de “aprender” de las experiencias que se le presenten.

1.6.- Ejemplos de Sistemas Expertos

- MACYSMA (Cálculos matemáticos)

Desarrollado para cálculos matemáticos, como por ejemplo resolución de ecuaciones algebraicas, problemas de física, química, cálculo de matrices, gráficas, etc. en los años 1968 y 1971.

En la actualidad es utilizado por la NASA.

- PROSPECTOR (Geología)

Desarrollado para la detección de yacimientos de minerales. Contiene una lnterfaz de lenguaje natural muy desarrollada y maneja probabilidades para la obtención de soluciones, dándole “valores” a cada posible

7

solución.

- SR1 ( Electromecánica)

Desarrollado para entrenamiento de sistemas de ensamblado, contiene ayuda visual por medio de un rayo láser , si se toca alguna pieza es capaz de identificarla y dar instrucciones de que hacer con ella.

Es utilizado principalmente en la industria automotriz.

- SEDVAD (Reactores Nucleares)

Desarrollado en México por profesores de la Universidad de Puebla. Es un Sistema de Diagnóstico el cual detecta las causas básicas que producen fallas en el vapor principal emun centro nucleoélectrico.

Se basa en la construcción de un árbol de fallas, utilizando encadenamiento hacia adelante.

- Otros sistemas que han sido desarrollados son Tutores inteligentes, Enseñanza en simuladores del saber, Bibliotecas Inteligentes, etc.

1.7.- Métodos de Representación de Conocimientos

- Marcos (Frames)

Combina reglas para crear un medio ambiente

- Redes semánticas

Incluyendo patrones para explicar en que contexto se esta dando la inferencia.

NOTA.

Para la creación de Sistemas Expertos se utiliza principalmente un lenguaje lógico llamado Prolog por la máquina de inferencias que contiene y por la forma de analizar la base de conocimiento que es por medio de backtrack. Tenemos otro lenguaje llamado LISP pero se utiliza principalmente para el área de la Robótica.

Prolog es la máquina de inferencia que contiene y el método que utiliza para analizar las bases de conocimiento es Backtrack.

8

2.- LENGUAJE NATURAL.

El presente trabajo desarrolla un esquema en el que independientemente de la información contenida en la base de conocimientos es capaz de realizar un diagnóstico sobre alguna consulta al sistema, utilizando un lenguaje Io mas parecido posible al que utilizamos comúnmente.

Pero este es tan extenso que se tuvo que restringir las estructuras a manejar para poder hacer las consultas.

Las restricciones que se establecieron, además del tipo de estructuras permitidas y algunos requerimientos mas serán especificados mas adelante.

2.1 .- Definición

Definimos como Lenguaje Natural la forma por la cual nos expresamos e informamos de ideas, pensamientos, sentimientos, razonamientos y emociones en nuestra vida cotidiana, pero por ser el medio por el cual nos comunicamos, esta influenciado por el estado de ánimo de los interlocutores, su nivel cultural, el medio ambiente, además de gesticulaciones, ademanes, tono de voz y muchos otros factores que intervienen en la comunicación.

Considerando lo anterior nos damos cuenta que el Lenguaje Natural utiliza diferentes medios de comunicación como son Oral, Escrita, Visual, etc..

2.2.- Características del Lenguaje Natural

- Contiene ideas implícitas.

Como en el caso de los refranes, los cuales son frases pero contienen ideas no descritas.

- En diferentes circunstancias una misma frase tiene un significado distinto.

Por lo regular depende de las circunstancias en que se utilice la frase, por ejemplo si alguna persona le comenta a otra “Estuvo sofocante”, y estas estuvieron mucho tiempo expuestas al sol se refieren al calor despedido por el sol, pero si hicieron una actividad que provocó mucho esfuerzo, se refieren al esfuerzo realizado.

- Una misma palabra tiene diferentes significados.

En español tenemos el caso de las palabras homónimas como son :

vino .- significa un licor ó el tiempo pretérito del verbo venir conjugado en tercera persona.

amo .- significa el dueño de algo 6 el tiempo presente del verbo amar conjugado en primera persona.

- Existen frases que contienen palabras implícitas.

9

Por ejemplo : “Su ladrido es imponente”, obviari.leíite estamos refiriéndonos a un perro, pero no lo mencionamos.

- Las palabras Sinónimas.

Son las palabras que se escriben diferente pero significan lo mismo. Hay palabras que tienen muchos sinónimos, por lo tanto es imposible saber todos los sinónimos de todas las palabras.

Las características anteriores originan confusiones y malinterpretaciones que son disminuidas por los gestos, ademanes, o por algún otro medio por el cual se lleva acabo la comunicación.

Pero en el caso de la creación de Sistemas Expertos es imposible utilizar otros medios de comunicación que no sea el escrito.

Además debe cumplir con ciertas reglas o estructuras predefinidas, porque es imposible identificar y manipular todas las que se utilizan en el Lenguaje Natural, por Io que se hace necesario un “Lenguaje Estructurado” para representar o interpretar alguna idea que pueda ser utilizado por un Sistema Experto.

Definimos al Lenguaje Estructurado como la comunicación escrita porla cual transmitimos ideas, pensamientos, etc., la cual cumple con estructuras predefinidas.

Este Lenguaje Estructurado es utilizado por un Sistema Experto para obtener información de una base de conocimientos.

La transformación de la información de Lenguaje Natural a Lenguaje Estructurado es proporcionalmente compleja a las estructuras reconocidas en los dos tipos de Lenguajes.

Ya que es necesaria una transformación del Lenguaje Natural al Lenguaje Estructurado para la obtención de información se debe establecer las estructuras que se reconocen en ambos lenguajes, es decir delimitar las estructuras permitidas en Lenguaje Natural, que pueden ser “transformadas” y las estructuras que sean “reconocidas” por el Sistema de Lenguaje Estructurado.

Por Io que a continuación describimos las estructuras utilizadasen la representación de conocimientos, para poder obtener información y obtener un diagnóstico dependiendo de la información en la base de conocimientos y no de la estructura de dicha base.

2.3.- Forma de Representación de Conocimientos

En nuestro caso requerimos que la base de conocimientos tenga la siguiente estructura:

<conocimiento> <textos>

<conocimiento> ::- si <enunciados> entonces

fin-si. <opción>

<enunciados> ::- cenunciado><conj><enunciado> / <enunciado>.

<opción> ::- otro <enunciados> .

10

<enunciado>

<pref>

<verbo>

<sujetos>

<sujeto>

cart>

<sustantivo>

<conj>

::- <pref><verbo> ( [ <sujetos> ] [ <complementos> ] , <identificador> ) I <diagnostico> .

::- no- I .

::- (Elemento de la Lista de verbos según el tema de la base de conocimientos) .

::- <sujeto><conj><sujeto> I <sujeto> I .

::- <art>- <sustantivo> I <sustantivo> .

::- el / la I los I unos / un I unas I ellos .

::- <token>.

::- y 1 o I pero.

<complementos> ::- <complemento>cconj><complemento> I <complemento> I

<complemento>

<token>

<letra>

<identificador>

<vat7

<num>

<diagnostico>

<texto( var )>

<palabras>

<nulo>

::- <token>.

::- <letra> I cletraxtokew.

::- a I b l c l .... I z l A l 01 ..... I Z/cnum>.

.. pregu / 1 1 9 9 1111 I texto( var ) .

::- cnum><num> I cnum> .

::- O 1 1 121 3 1 41 5 1 61 7 1 8 1 9 1 .

::- diagnostico ( [ <sujetos> ] , [ <complementos> ] , <texto (var)> ) .

:: - '' <palabras> " .

::- <token>cnulo>ctoken>.

::- (espacio en blanco).

2.4.- Notación

- enunciado es una cadena.

- sujetos y complementos son listas.

- Los elementos de sujeto o predicado están unidos por un guión bajo y serán un elemento de la lista.

11

Si existe más de un sujeto o predicado, cada uno de estos es un elemento de la lista al igual que las conjunciones que los unen (las conjunciones pueden ser y ó pero ).

Se requiere también de un archivo que contenga los verbos que se manejan en la base de conocimientos ya que por medio de los verbos identificamos las partes del enunciado.

La estructura de este archivo es:

<estructura> ::- <verbo> .

<verbo> ::- <token>

Ejemplo:

si no-arranca ( [ el-motor ] , [ ] , pregu ) entonces

fin-si . revise ( [ ] , [ ] , texto( ) )

si revise ( [ ] , [ ] , texto(1) ) entonces

fin-si . esta( [ la-caja ] , [ rajada ] , "" )

si esta( [ la-caja ] , [ rajada 1 , " ' I ) entonces

otro

fin-si .

diagnostico( [ ] , [ ] , texto(2) ) y revise ( [ ] , [ ] , texto(4) )

esta( [ la-caja ] , [ intacta ] , " ' I )

texto( 1 ) :- " visualmente el acumulador para conocer su condición ' I

texto( 2 ) :- " cambie el acumulador ". texto( 4 ) :- " visualmente los cables del acumulador ".

Si la consulta del usuario es que : "El motor no arranca" esta se transforma en : " no-arranca ( [ el-motor ] , [ ] , pregu ) " y obtenemos

si no-arranca( [ el-motor ] , [ ] , pregu ) entonces

fin-si. y de texto(1) obtenemos:

revise ( [ ] , [ ] , texto(1) )

texto( 1 ) :- " visualmente el acumulador para conocer su condición ".

Damos el diagnóstico parcial siguiente:

revise visualmente el acumulador para conocer su condición

Buscamos si tenemos en ta base algún predicado con

revise( [ ] , [ ] , texto( 1 ) )

12

y obtenemos

si revise( [ ] , [ ] , texto( 1 ) ) entonces esta( [ la-caja ] , [ rajada ] , " " )

fin-si.

Con lo cual realizamos el encadenamiento hacia adelante obteniendo otro diagnóstico parcial y buscamos si se puede seguir encadenando, para obtener un diagnóstico más completo.

2.5.- Interface de Lenguaje Natural

Para lograr establecer la comunicación entre Lenguaje Natural y la base de conocimientos requerimos que la estructura de la información para el Lenguaje Natural sea:

<Len-nat> ::- <sujetos><verbos><complementos><punto>.

<punto> ::- . 1

La cual se transforma a la estructura reconocida por el Sistema Experto que es <conocimiento> (definida anteriormente).

Se explica un módulo del Sistema para ejemplificar como trabajan los predicados en Prolog:

reconoce(T) sustantivo(T,Sust,Lista) ,

verbo-encontrado(Lista,Verbo,Sig) ,

complemento(Sig,Prim,Seg,Compl) ,

conv-ora(Sust,Verbo,Compl,M) ,

decide(M).

Cada cláusula realiza una tarea en específica como es:

- sustantivo(T,Sust,Lista) :-

I .- La primera tarea que realiza este predicado es verificar el valor de una de las variables el cual contiene la respuesta dada por el usuario en forma de lista y concatena los elementos que se encuentran antes del verbo exceptuando las palabras no, se, le. Estas son unidas por guiones bajos.

2.- Deja la cadena resultante en una lista y la lista sin sustantivo la instancia en otra variable, si no encuentra ningún verbo regresa una lista vacía;

Recordemos que el verbo lo busca en el archivo de verbos.

13

- verbo-encontrado(Lista,Verbo,Sig) :-

I .- Si se encontró alguna de las palabras no, se 6 le, concatena el verbo del enunciado con esta y regresa el verbo concatenado o solo en una variable.

2.- La lista sin el verbo la instancia.

- complemento(Sig,Prm,Seg,Compl) :-

I .- Une las palabras de la lista con guiones bajos.

2.- Regresa la lista resultado.

- conv-ora(Sust,Verbo,Compl,M) :-

I .- Une el contenido de las tres primeras variables en una sola lista dándole la estructura que puede ser reconocida por la base de conocimientos.

2.- Instancia el resultado en una variable.

- decide(M) :-

I .- Busca en la base de conocimientos información acerca del contenido en la variable enviada y regresa información si la encontró y si no marca un error.

14

Sistema lnterfaz entre Lenguaje Natural y Máquina de Inferencia

Manual de Usuario

Indice general

MANEJO DEL SISTEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

AYUDA QUE OFRECE EL SISTEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

COMO COMENZAR UN DIAGNOSTICO ...................................................................................... 20

POSIBLES MANERAS DE HACER PREGUNTAS ........................................................................ 20

RESPUESTAS DEL USUARIO A LAS PREGUNTAS HECHAS POR EL SISTEMA .................... 21

MENSAJES QUE MANDA EL SISTEMA ....................................................................................... 22

TIPOS DE ERRORES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

COMO CAMBIAR DE ARCHIVO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

COMO SALIR DEL SISTEMA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

16

MANEJO DEL SISTEMA

La lnterfaz del Lenguaje Natural para Sistemas Expertos consta de un solo diskette. Este diskette contiene el programa ejecutable llamado LEN-NAT.EXE. El usuario debe de asegurarse de tener disponible 512k de memoria para ejecutarlo.

Para comenzar se hace a partir del disco en donde se encuentre el archivo leng-nat.exe, tecleando lo siguiente:

Leng-nat

Una vez dentro del Sistema aparece una Ventana pidiendo el nombre del archivo que se quiere consultar. Este archivo es el que contiene la Base de Conocimientos, que se utiliza para obtenerinformación. Si porequivocación se teclea un nombre de archivo que no existe, se manda un mensaje de error y se vuelve a preguntar por el nombre del archivo, en caso necesario se debe indicar la ruta. La extensión del archivo no se da, el Sistema la proporciona automáticamente. Esta extensión es "SAC". v Nombre del archivo a consultar

I1 a:\Base-con

Nota : Base-con, es el nombre de la Base de Conocimientos a consultar.

Cuando no se recuerda el nombre de este archivo se teclea <ENTER> y el Sistema regresa al Sistema Operativo, no sin antes mandar el siguiente mensaje de advertencia.

ADVERTENCIA

El programa no funciona si no tiene una

Base de Conocimientos

Teclee <ENTER> para continuar..

Una vez que se teclea el nombre del primer archivo, se pide el nombre de un segundo archivo, que es el archivo de verbos. * Nombre del archivo de verbos I a:\Arch-Verbos 1

Nota : Arch-Verbos, es el nombre del Archivo de Verbos.

17

En este caso sucede lo mismo que en el caso anterior, cuando se da un nombre erróneo ó cuando no se sabe el nombre del archivo. La extensión que le concatena a este archivo es “ARI”, y el mensaje de advertencia que se manda en caso de no saber el nombre del archivo y teclear <ENTER> es :

ADVERTENCIA

El programa causara problemas si no tiene

una lista de Verbos

Teclee <ENTER> para continuar..

Cuando ya se piden estos 2 archivos, aparece un MENU,que muestra 4 opcionesque el Sistema ofrece. El Menú no desaparece hasta oprimir una de las teclas que se encuentran a la derecha de cada opción.

~ MENU MENU

AYUDA cF1>

COMENZAR <ENTER>

CAMBIAR ARCHIVO cF1 O>

SALIR C E S O

cF1>

<ENTER>

I CAMBIAR ARCHIVO cF1 O>

SALIR C E S O

Nota : A Io largo del manual se presentan ejemplos basados en el tema de Mecánica Automotriz.

18

AYUDA QUE OFRECE EL SISTEMA

En esta primera opción que ofrece el Menú, <AYUDA>, contiene información acerca de las posibles preguntas que se le pueden hacer al sistema. Estas preguntas dependen de la información que tenga la Base de Conocimientos. Esta opción se recomienda verla antes de comenzar a analizar un problema, ya que se puede hacer una pregunta al Sistema que no reconozca y manda un mensaje de error. A continuación se muestra un ejemplo.

Para poder entrar a esta opción se presiona la tecla <Fl>, y aparece una Ventana con la siguiente información:

~ INFORMACION

SISTEMA DE DIAGNOSTICOS

Las preguntas que se le pueden hacer al Sistema son :

1 - el motor no arranca

2 - el motor funciona uniformemente

3 - el motor de arranque hace girar muy despacio al motor

4 - el motor de arranque hace girar muy rápido al motor

Presiona <ENTER> para continuar.

El número máximo de preguntas que aparecen en pantalla son 4. Cuando este limite se rebasa, al presionar la tecla indicada se muestran las siguientes preguntas hasta finalizar.

Una vez que se terminan de leer las preguntas se presiona la tecla indicada y se regresa al MENU. En caso de no existir preguntas que hacer al Sistema se manda el siguiente mensaje :

MENSAJE

No hay preguntas para hacerle al Sistema

19

COMO COMENZAR UN DIAGNOSTICO

Esta segunda opción, <COMENZAR> comienza a analizar un problema. Para entrar a esta opción se presiona la tecla <ENTER>, y aparece la Ventana principal, en donde en su parte superior izquierda hay un letrero que dice INTERFAZ DE LENGUAJE NATURAL. Dentro de esta misma ventana hay una pregunta la cual dice :

I I INTERFAZ DE LENGUAJE NATURAL

Esta pregunta debe se ser contestada por el usuario, dando una de las posibles preguntas que el Sistema ofrece como ayuda. Esta pregunta se comienza a escribir en donde aparece el cursor (-), que sirve como un indicador. Este cursor aparece debajo de la pregunta que el Sistema hace.

NOTA : Es importante que antes de que el usuario pregunte al sistema, consulte la ayuda que se ofrece para evitar mensajes de error.

POSIBLES MANERAS DE HACER PREGUNTAS

La pregunta que el usuario hace debe ser escrita de la siguiente forma : Sujeto(s), seguido de un Verbo y por último el Complemento(s). El Sujeto y el Complemento pueden tener a lo mas 2 elementos. Con un ejemplo utilizando términos de mecánica, se explica.

EJEMPLO :

- Sustantivo con un solo elemento : el motor

- Sustantivo con dos elementos : el motor y el motor de arranque

- Sustantivo con dos elementos : el motor o el motor de arranque

Como se ve se pueden usar cualquiera de los 2 conectores “y” u “o”, para que el sustantivo pueda contener 2 elementos, esto también sucede con el Complemento. En caso de existir más de dos elementos el Sistema no reconoce la pregunta y manda un mensaje de error. Esta pregunta puede no tener complementos ó sustantivos, pero el verbo es importante que exista.

Existen varias maneras de poder escribir la pregunta, Insertando espacios en blanco al principio, entre cada palabra ó bien poner un punto final(.).

EJEMPLOS :

20

- El motor no arranca. <Sin espacios en blanco al principio de la pregunta y con punto final> - El motor no arranca. <Con espacios en blanco al principio de la pregunta y punto final>

- El motor no arranca. <Con mas de un espacio en blanco entre cada palabra y punto final>

- El motor no arranca <Sin punto final y sin espacios en blanco al principio de la pregunta>

Estas preguntas pueden ser escritas con letras mayúsculas o minúsculas, el usuario no debe de preocuparse por esto.

EJEMPLOS :

- EL MOTOR NO ARRANCA

- el motor no arranca

RESPUESTAS DEL USUARIO A LAS PREGUNTAS HECHAS POR EL SISTEMA

Una vez dadas estas recomendaciones, se comienza a analizar la pregunta que el usuario hizo al Sistema y se comienzan a hacer preguntas correspondientes sobre el tema a tratar. Estas preguntas las hace el Sistema y son contestadas por el usuario utilizando la palabras “si” o “no”.

Un ejemplo es

o bien

INTERFAZ DE LENGUAJE NATURAL

Especifica el problema

el motor no arranca

esta la caja rajada ? si



el motor no arranca

esta la caja rajada ? no

Nota : Las palabras que se encuentran en negritas son las respuestas que da el usuario a las preguntas del Sistema En caso de contestar algo distinto a estas dos palabras, se marca un error y se vuelve a repetir la pregunta.

21

MENSAJES QUE MANDA EL SISTEMA

Una vez que el usuario contesta aparecen en pantalla mensajes y se hace otra pregunta, en caso de no haber llegado al final del diagnóstico.



el motor no arranca

esta la caja rajada ? s i

cambie el acumulador y revise visualmente los cables del acumulador, en caso necesario apriete la conexión o cambie los cables. Pruebe el motor de arranque y su selenoide.

gira normalmente el motor de arranque ?

-

o bien



el motor no arranca


elimine la corrosión con una solución de bicarbonato compruebe el estado de carga del acumulador y revise visualmente los cables del acumulador, en caso necesario apriete la conexión o cambie los cables. Pruebe el motor de arranque y su selenoide.

gira normalmente el motor de arranque ?

Cuando el Sistema hace otra pregunta, se continua de la misma manera que se mencionó, con anterioridad en “Respuestas del usuario hechas por el Sistema”.

Este tipo de preguntas y respuestas continua hasta que el Sistema termine su diagnóstico y escriba en pantalla <FIN CONSULTA> seguido de “ TECLEE <ENTER> PARA CONTINUAR “. Una vez que se presiona esta tecla se regresa al MENU.

22



el motor no arranca


elimine la corrosión con una solución de bicarbonato compruebe el estado de carga del acumulador y revise visualmente los cables del acumulador, en caso necesario apriete la conexión o cambie los cables. Pruebe el motor de arranque y su selenoide.

gira normalmente el motor de arranque ? no

<FIN CONSULTA>

TECLEE <ENTER> PARA CONTINUAR

Como se ha visto el usuario solo realiza una pregunta a partirde la cual se comienza a analizar el problema para dar un diagnóstico.

TIPOS DE ERRORES

Los tipos de errores que el sistema detecta son :

- Cuando el nombre de los 2 archivos que se piden al principio es incorrecto. El mensaje es :

Error en el nombre del archivo

- Cuando la pregunta del usuario no se encuentre el la Base de Conocimientos. Esto sucede cuando el usuario hace una pregunta que no esta relacionada con el tema de la Base de conocimientos con la que se esta trabajando.

- Cuando la pregunta no esta bien definida. Es importante que la pregunta del usuario este escrita correctamente. Un ejemplo es : si la pregunta es el motor no arranca, entonces el Sistema empieza su diagnóstico, pero si la pregunta es motor no arranca, se manda un mensaje de error. Esto se debe a que

el Sistema no es capaz de verificar que se trata del mismo problema, y que la única diferencia entre ambos es el articulo.

El mensaje que se manda para estos dos últimos tipos de errores es

>> Problema no contenido en la Base de Datos

- Cuando la pregunta no tenga un verbo. Toda pregunta debe tener un verbo porque es la llave principal para la búsqueda en la Base de Conocimientos. Toda pregunta que no tenga un verbo manda siguiente

23

mensaje de error

Error sintáctico c verbo no encontrado >

- Cuando las palabras “si” o “no” son escritas incorrectamente. El mensaje es

Respuesta no reconocida

COMO CAMBIAR DE ARCHIVO

Como una tercera opción que ofrece el MENU es <CAMBIAR ARCHIVO>. Esta opción se elige cuando se quiere cambiar de Base de Conocimientos, es decir, cuando se quiere cambiar a un tema distinto al que se esta consultando.

AI oprimir la tecla <F1 O>, se piden los nombres de los 2 archivos (Base de Conocimientos y Verbos) y se sigue trabajando de la misma manera que al principio del programa, la única diferencia es que, cuando se presiona la tecla <ENTER>, que indica que no se recuerda el nombre de cualquiera de los2 archivos, se manda el mensaje de advertencia correspondiente a cada uno de los archivos pero no se sale del Sistema, sino que continua dentro del mismo y regresa al MENU.

Una vez que se cambia de archivo no se puede consultar el tema del archivo con el que anteriormente se estaba trabajando.

COMO SALIR DEL SISTEMA

Esta cuarta opci6n <SALIR>, permite al usuario abandonar el Sistema en el que se esta trabajando, o bien continuar en el mismo. Para entrar a esta opción hay presionar la tecla <ESC>, al ser presionada aparece la siguiente pregunta :

E l Seguro (silno)

AI responder esta pregunta tecleando la palabra “no”, indica que el usuario no quiere salir del Sistema y desea continuar trabajando con el. AI escribir esta palabra el mensaje desaparece y regresa al MENU, sin embargo si se teclea la palabra “si”, indica que el usuario desea salir del Sistema para ya no seguir trabajando con el. Cuando esta palabra se escribe, el mensaje desaparece y regresa al Sistema Operativo.

Cuando ninguna de estas dos palabras es escrita correctamente no se manda un mensaje de error simplemente se vuelve a hacer la pregunta.

24

Sistema Interfaz entre Lenguaje Natural y Máquina de Inferencia

Manual Técnico

lndice general

ESPECIFICACIONES DEL SISTEMA ................................................................................ 27

Primera Parte .............................................................................................................. 27-30

Código generado de la primera parte ....................................................................... 31-42

Segunda Parte ............................................................................................................ 43-45

Código generado de la segunda parte ..................................................................... 47-55

ESPECIFICACIONES DEL SISTEMA

Primera Parte

El presente Sistema consta de dos archivos llamados LEN-NATI y LEN-NAT2, y un archivo ejecutable llamado LEN-NATI. EX€. El cuerpo principal del sistema esta en el archivo LENG-NATI. Este archivo invoca al archivo LEN-NAT2.

El sistema esta escrito en un lenguaje de programación lógica llamado PROLOG. La idea de utilizarlo fue porque ofrece ventajas tales como :

- Permite que el código del programa sea escrito en forma más declarativa, rompiendo con el esquema tradicional de lenguajes que es por procedimientos. Esta es una ventaja de programación lógica.

- Utiliza backtrack.

- Maneja varios predicados con un mismo nombre, pero con distintos parámetros.

Dentro de este lenguaje, se puede implantar la técnica de programación de encadenamiento hacia adelante, que sirve para obtener soluciones al problema. Esta técnica es aconsejable cuando hay un número razonable de respuestas como en el caso de diagnósticos ó identificación de un sistema. Este es un sistema de diagnóstico que utiliza esta tkcnica para probaró rechazarcada una de las posibles respuestas, reuniendo solo la información más relevante.

En la primera parte del sistema, que es donde se inicia su ejecución, se encuentran ventanas que contienen mensajes de error, advertencias y un menú, también ofrece al usuario la opción de como iniciar el diagnóstico.

AI comienzo del programa, se piden dos nombresde archivosque son esenciales para que el sistema funcione adecuadamente. Estos archivos son :

1) Base de Conocimientos que el sistema requiere para la búsqueda de información

2) Un archivo de verbos

AI nombre del primer archivo, que es la Base de Conocimientosse le concatena la extensión “.SAC”. Es muy importante tomar en cuenta que toda base de conocimientos debe tener esta extensión, ya que el sistema no reconoce bases de conocimientos con otra extensión.

El segundo archivo contiene una lista de verbos, al nombre de este archivo se le concatena la extensión “.ARI”. E n caso de que el archivo no tenga esta extensión, sucede lo mismo que en el caso anterior.

En ambos nombres de archivos se concatenan las extensiones automáticamente, sin necesidad de que el usuario las especifique. Una vez que se tienen los archivos, se consultan y se presenta un MENU, que consta de 4 opciones.

Para poder comenzar a analizar un problema, se pregunta al usuario por el problema a analizar. Este da una respuesta que se interpreta como una pregunta, que se hace al sistema. Esta pregunta del usuario se guarda en una cadena que se convierte en letras minúsculas y se eliminan caracteres que no son útiles como son : espacios en blancos y puntos obteniendo como resultado una Cadena limpia. Cuando ya se tiene esta cadena se separa en TOKENS (palabra 6 palabras), para construir la estructura que el sistema requiere para poder trabajar. Esta estructura es :

verbo([sustantivos],[complementos],pregu)

De la cadena se buscan los elementos que la forman como son : sustantivos, complementos y verbo. Para empezar a reconocer estos elementos es necesario que exista un verbo VERBO, ya que es la llave principal tanto para la búsqueda en la base de conocimientos como para la construcción de la estructura del sistema. Es

27

posible que no se encuentren sustantivos ni complementos, pero el verbo debe de existir, por lo consiguiente se debe tener un archivo de verbos a consultar.

El sistema es de diagnósticos, el cual realiza preguntas que hace preguntas que van a ser contestadas por el usuario, ó bien el usuario hace preguntasque el sistema debe de contestar. En la estructura antes mencionada se encuentra la palabra “pregu”, que indica que es el usuario quién esta haciendo una pregunta y no el sistema. Cada vez que el usuario haga una pregunta al sistema se construye este tipo de estructura. Esta palabra es clave para identificar las posibles preguntas que el usuario puede hacer al sistema.

Cada vez que el usuario haga una pregunta al sistema se construye la estructura con la palabra “pregu” antes mencionada, ya que se pueden construir otro tipo de estructuras.

Para podersabersi se encuentra el verbo en la cadena, primero se reconoce el Sustantivo tomando cada uno de los Tokens, hasta reconocer un verbo o bien reconocer alguna de los siguientes modificadores : le, no y se. Cuando alguno de estos se reconoce se concatena al verbo de manera que el verbo queda representado de la siguiente forma :

Enunciado : el motor no arranca

Sustantivo : el-motor

Verbo : no-arranca

en caso de no existir ninguno de estos modificadores el verbo es representado como :

Enunciado : el motor arranca

Sustantivo : el-motor

Verbo : arranca

NOTA : Enunciado es la Cadena.

Todos los ejernplosque se muestran en esta primera parte del sistema, se relacionan con el tema de Mecánica Automotriz.

Como se observa en ambas representaciones cada token es separado de otro por medio de un guión bajo ( - ). Cuando se reconoce el verbo se toma la parte restante del enunciado, que se identifica como el complemento.

Una vez reconocido el verbo, sustantivos y complementos, se prosigue a concatenar corchetes izquierdos y derechos, tanto para los sustantivos como para loscomplementos, de manera que cada uno de estos elementos es representado por :


Sustantivo : [el-motor]

Verbo : no-arranca

Complemento : [ ]

en caso de no existir complementos o sustantivos, la representación para ambos casos es [ 1, que significa una lista vacía. Por último la cadena final se compone de la concatenación de los sustantivos, complementos, la

28

palabra “pregu”, paréntesis izquierdo, paréntesis derecho y el verbo, obteniendo la estructura que es requiere.


Estructura final : no,-arranca( [el-motor] , [ ] , pregu )

En la estructura del sistema los sustantivos y complementos pueden constar a lo mas de dos sustantivos o de dos complementos. En la cadena se puede identificar estos casos verificando si existen conectores como: “Y” u “o”.

A continuación se muestra un ejemplo, en donde existe un sustantivo o dos sustantivos en una enunciado y sus respectivas representaciones.

EJEMPLO

- Un Sustantivo


Representación : no-arranca( [el-motor] , [ J , pregu )

- Dos sustantivos

Enunciado : los platinos y el condensador están mal

Representación : están( [ [los-platinos] , y , [el-condensador] ] , [mal] , pregu ).

La representación para el caso del complemento es la misma que se utiliza para el sustantivo. Dentro del programa se utilizan Estructuras de Datos tales como : listas y cadenas. La estructura de datos que más se utiliza dentro de esta primera parte del sistema, es el tipo cadena. Uno de los predicados del lenguaje prolog, que maneja estetipode estructura esstring-search(Subcadena,Cadena,Localización), que busca unasubcadena y da la posici6n inicial de donde se encuentra esta.

Tomando un módulo del programa para ver como trabaja este predicado tenemos

separa( $$ , [ ] ). separa( X , [ X I 1

not(string-search($ $ , X , P ) , not(string-search($.$ , X , P ) , ! .

(string-search($.$ , X , P ) , substring( X , P , 1 , H ) , string-length( X , Long ) , L1 is Long - 1 , L2 is L1 , P1 is o ; string-search($ $ , X , P ) , substring( X , O , P , H ) , string-length( X , Long ) , L1 is Long - P , P I i s P + 1 , L2 is L1 - 1) ,

s e p a r a ( X , [ H / L ] )

29

substring( X , P1 , L2 , Res) , separa( Res, L ) .

Este módulo es recursivo y consta de dos parámetros, una cadena de entrada y una lista en donde se guardan las palabras que forman parte de la cadena de entrada.

Dado que cada palabra se encuentra separada por un espacio en blanco, lo que se hace es identificar una palabra, para guardarla en una lista. Una vez hecho esto, se vuelve a invovar al módulo, mandando la cadena sin contener la palabra que fué identificada anteriormente, La búsqueda continua hasta llegar a alguno de los doscasosbasesqueson:

- Cuando la cadena este Ivacía

ó

- Cuando la cadena no tenga espacios en blanco ($ $), ni puntos.

Nota : La representación de una cadena en el lenguaje prolog es entre signos de pesos ($$).

30

Código generado de la primera parte

Dentro de esta primera parte del sistema el código que se genera es el siguiente :

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% Integrantes : Arredondo Pérez Beatriz. % % %% Rojas Galindo Minerva Yo % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

:- public main/O. :- public conv_min/2. :- public error/O. :- extrn busca/l . :- extrn espera/O. :- extrn busca-verbo/l . :- op(70,fx,si). :- op(lOO,xfy,entonces).

% Predicados utilizados por este módulo.

% Predicados que se usan fuera de este módulo.

% Operandos para reconocer una estructura.

YO Predicado utilizado por prolog, para saber donde comienza el programa.

main CIS, borra-todos, principia

% Predicado que dibuja una ventana en pantalla, con un Menu.

inicio CIS, create-popup('M E N U' , (5,20) , (1 5,60) , (31 ,-31) ), tmove(l,6), write($ AYUDA F1 >S), tmove(3,6), write($ COMENZAR < ENTER >$), tmove(5,6), write($ CAMBIAR ARCHIVO < F1 O >$), tmove(7,6), write($ SALIR < ESC >$), repeat, Wb(X,Y), verifica-tecla(X,Y).

% Predicados que verifican la tecla presionada.

verifica-tecla( X , Y ) Y == 59, exit-popup, bpreg,exit-popup,inicio,!.

verifica-tecla( X , Y )


X == 13, exit-popup, ventana, ifthenelse(principal,volver,volver),!

31


X == 27, fin-proceso,!.

Y == 68, exit-popup, borra-todos, archivo(? ,B), ifthen(not(B = $F$),archivo(2,BI)), inicio.

% Predicado que elimina las cláusulas de las Base de Datos.

borra-todos

borralos( [ ] ). borralos( [C I L] )

findall(si A entonces B, si A entonces 8, L), borralos(L).

retract(C), borralos(L).

YO Predicado que encuentra en la Base de Datos todas las ocurrencias O/O que contengan la palabra “pregu”, además se despliega en pantalla todas % las ocurrencias de esta palabra.

findall(S,(si S entonces C,S =..L,member(pregu,L)),Ll), obt-ora(L1 ,L), crea-ven(L).

nl,functor(H,X,A), Verbo = X, arg(1 ,H,Sust), elimin(Sust,Al), arg(2,H,Com), elimin(Com,A2), con-preg(Verbo,Al ,A2,C),

!.

A = L.

con-preg( Verbo, Sust, Com, X4 ) :- string-term(S,Sust), elim-ue(S,$$,Sl), string-term(C,Com), elim-ue(C,$$,Cl), string-term(V,Verbo), elim-ue(V,$$,Vl), ifthenelse(S1 = $[]$,XI = $$,concat(Sl,$ $,XI)),

32

elim-ue( O, A, Or )

elim-ue( O, A,Or )

concat(X1 ,V1 ,X2), concat(X2,$ $,X3), ifthenelse(C1 = $[]$,concat(X3,$$,X4),concat(X3,Cl ,X4)).

not(string-search($-$,O,P)), concat(A,O,Or).

string-search($-$,O,P), substring(O,O,P,H), string-length(O,Long), L1 is Long - P, P1 i s P + 1, L2 is L1 - 1, substring(0,Pl ,L2,Res), concat(H,$ $,Hl), concat(A,Hl ,AI), elim-ue(Res,Al ,Or),!.

% Predicado que pregunta por el nombre de la Base de Conocimientos y el YO archivo de los verbos.

principia

archivo( N, B )

archivo(1 ,6), ifthen(not(6 = $F$),archivo(Z,Bl)), ifthen(not(B1 = $F$),inicio).

create-popup('ARCHlV0',(9,16),(13,70),(31,-31)), tmove(0,5), case([N is 1 -> write($Nombre del archivo a consultar : $), N is 2 -> write($ Nombre del archivo de verbos : $)I), leel(N,B).

O/O Predicado que lee una cadena de caracteres.

leel( N, B)

concatena( X, N )

nl, tmove(2,16), read-line(O,X), (X = $$,exit-popup, ifthenelse(N is 1 ,men-final,men-finall), B = $F$; B = $V$, concatena(X,N)).

ifthenelse(N = 1 ,concat(X,$.SAC$,Xl), concat(X,$.ARI$,Xl)), ifthenelse(directory(X1 ,D ,-,-,-, J, consulta(Xl), corrige(N)).

% Predicado que remueve caracteres de un buffer.

33

corrige(N) flush, ven-error, exit-popup, archivo(N,B).

YO Predicado que consulta una Base de Datos.

consulta(X1) consult(Xl), exit-popup.

YO Predicado que inicia el proceso.

principal leepregunta(Pregunta), conv-min(Pregunta,Conversion), separa(Conversion,L), elimina(L,T), reconoce(T),!.

O/O Predicado que hace una pregunta al usuario.

leepregunta(Pregunta) nl, write(' Da el problema a consultar I ) ,

nl, tmove(2,1), read-line(0,Pregunta).

O/O Predicado que convierte una cadena de caracteres con letras mayúsculas a minúsculas.

convmin( [ ] , [ ] ) . convmin( [ H I L ] , [ X I Xs ] ) :-

min(H,X), convmin(L,Xs).

conv-min( Cad, Cadco ) list-text(Aux,Cad), convmin(Aux,LisSa), list-text(LisSa,Cadco).

min( E, E )

min( E, E)

min( E, S)

E = 32, .. I

E = 46, !.

E 92, S is E + 32, !.

34

min( E, E)

not(string-search($ $,X,P)), not(string-search($.$,X,P)), !.

(string-search($.$,X,P), substring(X,P,l ,H), string-length(X,Long), L1 is Long - 1, L2 is L1, P1 is o; string-search($ $,X,P), substring(X,O,P,H), string-length(X,Long), L1 is Long - P, PI is P + 1, L2 is L1 - I), substring(X,Pl ,L2,Res), separa(Res,L),!.

YO Predicado que elimina puntos y espacios de una cadena.

elimina( [ $.$ 1 T J , L ;\ !, elimina(T,L).

!, elimina(T,L).

elimina( [ $$ I T ] , L )

e l i m i n a ( [ H I T ] , [ H ( L ] )

elimina( [ ] , [ ] ) . elimina(T,L).

YO Predicado que reconoce una oración (sustantivo,verbo y complemento).

reconoce(T) sustantivo(T,Sust,Lista), verbo-encontrado(Lista,Verbo,Sig,F), (F= $v$, complemento(Sig,Prm,Seg,Compl), conv-ora(Sust,Verbo,Compl,M), decide(M), !; true).

YO Predicado que obtiene los sustantivos de una oración.

une-sustantivo( [ H 1 T 1 , Res , [ H I T ] ):-

35

string-term(H,Hl), busca-verbo(Hl), asigna-nulo(Res), !.

une-sustantivo( [ H I T ] , Res , Lista ):- !, concat(H,$$,Concl), sustantivo(T,Concl ,Res,Lista).

sustantivo( T, Sust, Lista)

sustantivo( [ ] , Con2 , F , 1: H I T ] )

!, une-sustantivo(T,Sust,Lista).

error-verbo, fail.

sustantivo( [ H I T ] , Conc2 , F , [ H I T ] ):- string-term(H,Hl), busca-verbo(Hl), concat(Conc2,$$,F).

sustantivo( [ H I T ] , Conc2 , F , [ H I T ] ):- member(H,[$no$,$se$,$le$]), concat(Conc2,$$,F).

sustantivo( [ H I T ] , Conc2 , F , Res ):- concat($-$,H,Conc3), concat(Conc2,Conc3,Conc4), sustantivo(T,Conc4,F,Res),!.

YO Predicado que obtiene un verbo de una oración.

verbo-encontrado( [ H I T ] , Vb , R , F ):- member(H,[$se$,$no$,$le$l), concat($$,H,V), concatena(T,V,Vb,R,F),!. verbo-encontrado([HIT],H,T,$v$).

% Predicado que obtiene el complemento de una oración.

complemento( Sig , Prm , Seg , Compl ):- asigna-prim(Sig,Prm,Seg), une-compl(Seg,Prm,Compl).

une-compl( [ ] , Conc , Res ) concat(Conc,$$,Res)

36

une-cornpl( [ H 1 T ] , Conc , Res ) :- concat($-$,H,Conc2), concat(Conc,Conc2,Concl), une-cornpl(T,Concl ,Res).

decide( M )

decide( M )

comienza(M), !.

% Predicado que construye una oración para la búsqueda en la base de datos.

conv-ora( Sust, Verbo, Compl, M) :- checa(Sust,X2,LI), checa(Cornpl,X3,L2), une_ter(XZ,XB,Ct), concat(Verbo,Ct,C), string-term(C,M).

checa( Base , X1 , L ) (Base = $$, concat($[$,$l$,Xl); conv-lista(Base,L), obten-predi(L,$$,X), checar(X,Xl)).

% Predicado que concatena la oración final.

une-ter( X1 , X3 , Xt ) concat(X1 ,$,$,M), concat(M,X3,Ml), concat(M1 ,$,$,M2), concat(M2,$pregu$,M3), concat($($,M3,M4), concat(M4,$)$,Xt).

% Predicado que coloca en una lista, los elementos de una cadena.

conv-lista( X , [ L ] ) not(string-search($-y-$,X,P)), not(string-search($-o-$,X,P)), concat($[$,X,M), concat(M,$]$,L).

conv-lista( X , [ H 1 T ] ;I (string-search($-y-$,X,P); string-search($-o-$,X,P)), (P is o, obten-conec(X,H,Pl ,P2);

37

P1 is P, substring(X,O,P,A), concat($[$,A,L), concat(L,$l$,H), string-length(X,Long), L1 is Long - P,

substring(X,Pl ,P2,D), conv-lista(D,T),!.

P2 is LI),

obten-predi( [ L ] , A , X ) concat(A,L,B), concat($[$,B,Bl), concat(B1 ,$]$,X).

obten-predi( [ H I T ] , A , X ) concat(A,H,F), obten-predi(T,F,X), !.

YO Predicado que verifica si hay conectores o no en una cadena.

checar( B , N ) (not(string-search($,y,$,B,P)), not(string-search($,o,$,B,P)), string-length(B,Long), P2 is Long - 2, substring(B,l ,P2,N); N = B).

% Predicado que obtiene el conector de una oración.

obten-conec( X , C , P1 , P2 ) :- substring(X,l,l ,A), concat($,$,A,Al), concat(A1 ,$,$,C), string-length(X,Long), P1 is 3, P2 is Long - P1.

% Predicado que coloca en una lista, los elementos de una cadena.

conv-lista( X , [ L ] ) not(string-search($-y-$,X,P)), not(string-search($-o-$,X,P)), concat($[$,X,M), concat(M,$]$,L).

conv-lista( X , [ H I T ] ) (string-search($-y-$,X,P); string-search($-o_$,X,P)), (P is o, obten-conec(X,H,Pl ,P2); P I is P.

38

substring(X,O,P,A), concat($[$,A,L), concat(L,$]$,H), string-length(X,Long), L1 is Long - P, P2 is L l ) , substring(X,Pl ,P2,D), conv-lista(D,T),!.

%Predicado que verifica si un elemento es miembro de una lista.

member( X , [ X 1-1 . member(X, [ - I L])

member(X,L).

% Predicado que despliega una ventana con informacion.

crea-ven( [ ] ) create-popup(’MENSAJE’,(9,20),(13,65),(31,-31)), tmove(0,2), write($No hay consultas para hacerle al sistema$), tmove(2,7), write($Teclee <ENTER> para continuar..$), flush, get0-noecho(M),!.

crea-ven( L ) create-popup(‘lNFORMAClON’,(1,3),(23,72),(31,31)), tmove(l,20), write($ SISTEMA DE DIAGNOSTICOS $), tmove(3,1), write($Las consultas que se le pueden hacer al sistema son : $), informacion(O,L), tmove(20,35), write($Presiona <ENTER> para continuar.$), repeat, keyb(X,_), X == 13.!.

YO Predicado que espera sea presionada la tecla ENTER.

presiona-tecla tmove(20,35), write($Presiona <ENTER> para continuar.$), repeat, keyb(X,_), X == 13, CIS.

YO Predicado que escribe informacion dentro de una ventana.

information( N , [ L ] ) nl,nl, write($ - $),

39

write(L),write($.$).

information( N , [ H 1 T ] ) nl,nl, write($ - $),write(H), write($.$), N I is N+1, (NI is6, presiona-tecla, Na is O; Na is NI), informacion(Na,T).

YO Predicados que manda dos tipos de mensajes de error.

error-verbo ni, write(' Error Sintactico <c Verbo no encontrado >>. I ) ,

espera, nl.

error write(' >> '), write('Prob1ema no reconocido.'), espera, nl.

% Predicado que pregunta si se desea continuar o no

fin-proceso

repite( R )

create~popup(",(l3,25),(16,55),(31,-31)), write($ Seguro (siho) ? $), repite(R), !.

read-line(O,X), conv-min(X,R), ifthenelse(R=$si$,termina,llamada(R))

llamada( R ) (R \= $no$, flush, exit-popup, fin-proceso; exit-popup, exit-popup,inicio), .. I

% Predicado que concatena a una cadena un guión bajo.

concatena( [ C 1 R ] , V , Vb , R , F ) :- (string-term(C,Cl), c 1 I

40

concat($-$,C,Res), concat(V,Res,Vb), F=$v$; error-verbo, F= $f$).

% Predicado que manda a la primera ventana.

volver exit-popup, inicio.

% Predicado que asigna vacío a una variable.

asigna-nulo( Res ) list-text("",R.es)

YO Predicados que mandan mensajes a pantalla.

men-final

men-final1

ven-error

create-popup('ADVERTENCIA',(9,20),(14,65),(31,-31)), tmove(0,2), write($ El programa no funciona si no tiene una $), tmove(l,9), write($ Base de Conocimientos $), tmove(3,5), write($Teclee <ENTER> para continuar..$), flush, get0-noecho(M), exit-popup,!.

create~popup('ADVERTENCIA',(9,20),(14,65),(31,-31)), tmove(0,2), write($El programa no funciona si no tiene $), tmove(l,9), write($ una lista de Verbos $), tmove(3,5), write($Teclee <ENTER> para continuar..$), flush, get0-noecho(M), exit-popup,!.

create~popup(",(l2,20),(16,65),(31,-31)), tmove(0,2), write($ Error en el nombre del archivo $), tmove(2,7), write($Teclee <ENTER> para continuar..$), flush, get0-noecho(M), exit-popup,!.

41

O/O Predicado que dibuja una ventana.

ventana CIS, create-popup('lNTERFA2 DE LENGUAJE NATURAL', (2,6),(23,75),(31,-31)).

O/O Predicado que cierra las ventanas.

termina exit-popup, exit-popup.

42

Segunda Parte

La segunda parte del desarrollo es la interfazentre el usuario y la máquina de inferencia, la cual se encarga de obtener la información de la base de conocimientos que cumpla con la consulta realizada por el usuario.

Para poder realizar la interfaz consideramos que: - la consulta es transformada para que cumpla con la estructura

verbo( [ sustantivo(s) ] , [ complemento(s) ] , I ' ).

- la información de la base de conocimientos presente una estructura de la forma :

si condición entonces

fin-si . acción

ó


otro

fin-si .

accionl

accion2

y por mediode la máquina de inferencias buscamos en la base de conocimiento lasestructurasque contengan en la parte de condición la consulta del usuario y obtenemos el predicado que corresponda a la parte de acción.

El hecho que corresponda en alguna estructura en la parte de condición la llamaremos instanciar. La acción encontradase transforma para obteneruna respuesta para el usuario. Esta transformación consiste

en almacenar en una lista las partesdel predicado como son el functor (el verbo), y los argumentos (sustantivos, complementos, y el texto que contiene en caso necesario una explicación de como realizar la acción dada en la respuesta).

Otro punto esque los sustantivos, complementos y textos están unidos por un guión bajo, por lo que tenemos que separarlos para dar la presentación adecuada para el usuario y contestar su consulta, esta respuesta se almacena en una cadena.

Como es un sistema de diagnóstico el usuario hace una consulta, la cual es contestada por el sistema experto y este basado en la consulta que le fue hecha pregunta al usuario para poder estructurar un diagnóstico o dar soluciones parciales del problema.

Por lo que se instancian algunas variables que el sistema experto transforma para preguntar al usuario y dependiendo de las respuestas se busca en la base de conocimientos., se deben validar tanto las consultas que hace el usuario, así como las respuestas del mismo, y si no se encuentra una respuesta se marca un error.

Los predicados ofrecidos por prolog utilizados en esta parte son:

op(Num, x f x, si) :- Define un operando.

write(N) :- Escribe una cadena en pantalla.

ifthen(A , B) :- Actúa como un if A then B.

if'thenelse(A , B , C) :- Actúa como un if A then B else C.

flush :- Limpia el buffer.

concat(A , B , C) :- Une dos cadenas y el resultado lo deja en otra cadena.

43

read-line(M) :- Lee una cadena.

string-search(A , B , C) :- Busca un caracter en una cadena y da su posición

substring(A , B , C) :- Obtiene una subcadena de una cadena dada especificando en donde empieza cuantos caracteres contiene.

string-length( M , N ) :- Obtiene la longitud de una cadena.

functor(A , B) :- Obtiene el nombre de un predicado.

clause(A , B) :- Obtiene la cabeza de un predicado.

arg(A I B , C) :- Obtiene un argumento especificado de un predicado.

Explicaremos como obtiene un diagnóstico el sistema por medio de un ejemplo.

EJEMPLO:

En este ejemplo consideramos que la base de conocimientos contiene información del tema de las posibles fallas de un automóvil utilizando una estructura de SI condición ENTONCES acción FIN-SI. Donde acción es la consulta hecha por el usuario después de una transformación.

Consideramos que la base de conocimientos es:

si no-arranca( [ el-motor] , [ ] ) entonces

fin-si.

si revise( [ ] , [ ] , texto( I ) ) entonces esta( [ la-caja ] , [ rajada ] , '' " ) fin-si .

revise ( [ ] , [ ] , texto( 1 ) )

si esta( [ la-caja ] , [ rajada ] , " " ) entonces

otro diagnostico( [ ] , [ ] , texto( 2 ) ) y revise( [ ] , [ ] , texto( 1 ) )

si esta( [ la-caja ] , [ intacta ] , " " ) entonces

fin-si. diagnostico( [ ] , [ ] , texto( 3 ) ) y compruebe( [ ] , [ ] , texto( 5 ) )

texto( 1 ) :- " visualmente el acumulador ' I .

44

texto( 2 ) :- " cambie el acumulador".

texto( 3 ) :- " elimine la corrosión con una solucitjn de bicarbonato".

texto( 5 ) :- " el estado de carga del acumulador"

revise( [ ] , [ ] , texto( 1 ) )

Partimos de que la consulta hecha por el usuario al sistema es: El motor no arranca, el sistema se encarga de transformarla y se obtiene

no-arranca( [ el-motor] , [ ] , pregu )

La máquina de inferencias de el lenguaje prolog busca en la base de conocimientos alguna estructura que en su parte de condición corresponda con la anterior y se obtiene :

si no-arranca( [ el-motor] , [ ] ) entonces

fin-si. revise ( [ ] , [ ] , texto( 1 ) )

De aquí obtenemos la acción siguiente:

revise ( [ ] , [ 1, texto(?) )

Analiza la parte de los sustantivos, transformando lo que hay en ella, es decir separando las palabras que se encuentran unidas por guiones bajos., lo mismo se hace con los predicados, después se busca la información de texto (1).

y obtiene texto(1)

visualmente el acumulador

Se va formando el diagnóstico parcial para el usuario, guardando en una lista primero el enunciado que se formo de los sustantivos (en este caso ninguno), después se anexa el verbo que es el primer elemento de la estructura encontrada (la estructura de acción, en este caso es revise), enseguida el enunciado que se formo de la parte de los predicados en este caso ninguno, y por último la información obtenida de texto(l), que es visualmente el acumulador, y obtenemos el diagnóstico parcial siguiente:

revise visualmente el acumulador

Se busca si de la acción obtenida hay alguna estructura en la cual esta se encuentre como condición, si no se encuentra ninguna se da porterminado el diagnóstico, pero si existe alguna se repite el procedimiento anterior.

En este caso se encontró en la siguiente estructura:

si revise( [ ] , [ ] , texto( 1 ) ) entonces esta( [ la-caja ] , [ rajada ] , ' L " ) fin-si .

Antes de transformar la acción obtenida (en este caso esta( [ la-caja ] , [ rajada ] , I ' ) ) se busca que esta acción se encuentre en alguna estructura de tipo pregunta como la siguiente


otro accionl

accion2

45

fin-si . y encontramos

si esta( [ la-caja ] , [ rajada J , " " ) entonces

otro diagnostico( [ ] , [ ] , texto( 2 ) ) y revise( [ ] , [ ] , texto( 4 ) )

.. -

esta( [la-caja], [ intacta ] , " " ) fin-si .

Por lo que la acción ( esta( [ la-caja ] , [ rajada ] , " " ) ) se presenta en forma de pregunta y obtenemos:

esta la caja rajada 7

Las respuestas válidas para el usuario son: si ó no, si responde cualquier otra cosa se manda un mensaje de error.

la respuesta es inválida

y el sistema vuelve a realizar la pregunta

esta la caja rajada ?

si la respuesta es si, la acción encontrada es diagnostico( [ ] , [ ] , texto( 2 ) ) y revise( [ ] , [ ] , texto( 1 :) )

transformando la primera parte diagnostico( [ J , [ ] , texto( 2)) encontramos que contiene la palabra diagnostico la cual nos indica que es un diagnóstico final por lo que ya no es necesario buscar en la base de conocimientos si existe otra estructura que la contenga por loque solo analizaremos su información para presentarla al usuario.

La estructura no contiene sujeto, ni predicado y solo información en el texto (2).

texto(2) :- " cambie el acumulador".

por lo que el diagnóstico parcial queda:

cambie el acumulador,

La segunda parte de la acción es :

revise( [ ] , [ ] , texto( 4 ) )

Con la cual se puede seguir encadenando, las estructuras para seguir con los diagnósticos parciales.

Volviendo al caso de la estructura de la pregunta y considerando que el usuario contesto que no, la acción es la parte después del la palabra otro y corresponde a:

esta( [ la-caja] , [ intacta 1, '"' )

Buscamos si no es una pregunta, si le es la presenta como pregunta y si no la da como diagnóstico y trata de enlazar con otra estructura.

46

Código generado de la segunda parte

El código generado de la segunda parte del sistema es:

YO Declaración de operandos para reconocer la estructura de la base de datos,

:-Op(7O, fX, Si).

:-0p(50, xfy, [Y, o, perol >.

:-op(l00, xfy, entonces).

:-op(80, yfx, otro).

:-0p(60, xf, fin-si).

% Predicados que buscan en la base de conocimiento la información que coincida con el %enunciado obtenido de la consulta hecha por el usuario verificando en la información %contenida en las estructuras establecidas.

comienza(>() ! , instancia(>() ,

fin-busca .

comienza(Preg) si Preg entonces

otro

fin-si, haz-lista(Resp, Lista), anal-lista(Lista).

Resp

Preg 1

% Cuando la podemos encadenar varias veces la información para obtener diagnósticos %parcialres

instancia(Preg) si Preg entonces

otro

f i n-si , anal-preg(Preg, Revise, Resp), ! , ifthenelse( Resp = $no$,

Revise

Pregl

decide(Preg1, Respl , Preg2), Respl = $$) ,

case( [ Respl = $no$ -> instancia(PregZ), Respl = $si$ -> ( ! , ifthenelse( es-pregunta(Preg1, Resp3),

instancia(Resp3),

47

instancia(Preg1) ) ) I (!, write($ $) ) ] ).

instancia(Preg)

instancia(Preg)

si Preg entonces

fin-si, haz-lista(Revise, Lista), anal-lista(Lista).

Revise

! , ver-diagn(Preg).

O/O Convierte en cadena la información obtenida de la base de conocimientos y si son varios %elementos los separa.

haz-lista(Revise, Lista) string-term(Revise1, Revise), separa(Revise1, Lista).

YO Verifica cada elemento encontrado, checando si se trata de una conjunción.

anal-lista([ I) !

anal-lista(Lista) da-elem(Lista, Elem, Listal), string-term(Elem, Eleml), ifthenelse( miembro(Eleml),

escr-conj(Eleml), anal-sig(Elem1) ),

anal-lista(Lista1).

% Verifica si el elemento es una pregunta para el usuario y la es la escribe en pantalla.

decide(Preg1, Resp, Preg2) ifthenelse( es-pregunta(Preg1, Preg2),

haz-pregunta(Preg1, Resp), ( instancia(Pregl), Resp =$$ ) ).

% Analiza si el elemento puede seguir encadenandose y obtener mas información o es un %diagnóstico final.

anal-sig(Elem1) ifthenelse( es-pregunta(Elem1, Var) ,

( ! , selec(Elem1, Preg2) ), ( dec-cont(Elem1, Preg2), !,

anal_preg2(Preg2) ) ).

YO Predicado que checa si el elemento es una conjunciiin.

48

miembro(Elem1) member(Elem1, [ y, o, pero, [ ] I).

YO Analiza si el segundo elemento obtenido puede ser una pregunta

! , ifthen( Preg2 \= [ ] ,

( haz-lista(Preg2, Lista3), separa-busq(Lista3) ) ).

% Escribe en pantalla la conjunción

escr-conj(Elem1) write($ $1, ifthen( Eleml \= [ 1,

nl. write(Elem1) ),

% Asigna valor a Preg2 donde este indica si se continua buscando información o es un %terminal

dec-cont(Elem1 ,Preg2) ifthenelse( ver-diagn(Eleml),

Preg2 = [ 1, (instan(Eleml), !, selec(Elem1, Preg2) ) ).

YO Checa que se encuentre la etiqueta “diagnostico” en el elemento para dar una respuesta a la %consulta.

ver-diagn(E1em) functor(Elem,Nom,J, Nom = diagnostico, escr_arg3(Elem,l).

O/O Checa que el elemento coincida con la estructura que identifica en la base de conocimientos %a una pregunta.

es-pregunta(Preg,Respl) si Preg entonces

otro

fin-si.

Resp

Respl

YO Separa los elemento que forman una condición recursivamente

!.

49

separa-busq(Lista) da-elem(Lista, Elem, Listal), string-term(Elem, Eleml), ifthenelse( miembro(Eleml),

escr-conj(Eleml), es-liga(Elem1) ),

separa-busq(Lista1).

YO Identifica cuando la cabeza del elemento coincide con la palabra “diagnostico”

es-liga(Var) . I I

functor(Var, Nom, J, ifthen( (Nom \\= diagnostico, not (es-pregunta(Var, 3 ) ),

instan(Var) ), nl, nl, instancia(Var).

O/O Obtiene un elemento de una lista.

da-elem( [In I Cuer], In , Cuer) :- !.

da-elem( Cab, Cab, [ ] ) !.

O/O Despliega el enunciado FIN DE CONSULTA y espera respuesta del usuario

fin-busca ni, nl, write($ FIN CONSULTA $), !, espera.

O/O Selecciona si el elemento se encuentra en una estructura de tipo pregunta o de diagnostico

selec(Revise, Preg)

selec(Revise, Preg)

si Revise entonces

fin-si, !.

Preg

si Revise entonces

otro

fin-si,

Preg

Preg 1

50

! , instancia(Revise).

selec(Revise, [ ] ).

% Verifica que el tercer elemento de la estructura sea un verbo y lo escribe.

instan(Var) functor(Var, Nom, 3), busca-verbo(Nom), escr_arg3(Var, O).

% Busca si el verbo se encuentra definido

busca-verbo(Nom) separa(Nom, [ Cab 1 Cuer ] ), miembro(Cab), Cuer.

busca-verbo(Nom) Nom.

YO Obtiene la información del tercer argumento del predicado y Io despliega

escr_arg3(Var, Band) ! ,

arg(3, Var, Res), ifthenelse( (Res\\=[ 1, Res\\=pregu, Res\\=”” ),

(clause(Res, Lis) , list-text(Lis, L i l ) ), atom-string(Li1, $ $) ),

da-resul(Var, Band), write(Li1).

% Verifica si existe consunción en la lista y si la encuentra la separa

var(Var, Lista) string-term(Var1, Var), !, separa(Var1, [ Cab I Cuer ] ), conj(Cuer, Cuerl), revisa(Cab, Cuerl, Lista).

% Verifica si el elemento es vacio

conj(Elem, Res) ifthenelse( Elem == [ 1,

Res = [ 1, no-conj(Elem, Res) ),

! .

conj( [ Cuer ] , Cuer ) !.

51

no-conj( [ Cab I Cuer] , Res) :- no-conj(Cuer, Res) , ! .

YO Agrega elementos a una lista

revisa( Cab, [ ] , Cab).

revisa( Tot , Cuer , Lista) string-term( Tot , Totl ), string-term( Cuer , Cuerl ), append( [ Totl 1 , [ Cuerl ] , Lista ) , !.

espera ni, write($ Teclee <RET> para continuar $), flush, get0-noecho(M) , !.

% Predicado que controla el realizar una pregunta y decidir la respuesta

anal-preg(Preg , Var , Resp) !, var( Preg, Pregl), string-term( Preg2, Preg ), separa( Preg2, Respl ), obt-conj( Respl, Conj ), case([ (Conj = $y$; Conj=$pero$) -> pregy(Preg1 ,Resp),

Conj = $o$ -> prego(Preg1 ,Resp) I (string-term(Preg1 ,Obt),

! , haz-pregunta(Obt,Resp)) ] ),

ifthen( Resp = $si$, ( haz-lista(Var, Cont), anal-lista(Cont) ) ).

YO Escribe a pantalla una " y " cuando la conjunción es esta

% Manda al predicado haz-pregunta con el primer elemento de la lista que tiene como Yoparámetro

obt-resp( [ Preg I Sig ] , Resp) :- haz-pregunta(Preg, Resp).

% Escribe a pantalla una I ' 'o " cuando la conjunción es esta

52

prego( [ Preg I sig 1 , Resp) pregunta(Preg), write($ o $), obt-resp(Sig, Resp)

YO Obtiene el segundo elemento de la lista que recibe como parámetro

! .

obt-conj( [ Cab 1 Cuer] , Res) :- letra( Cuer , Res ), ! .

YO Obtiene el primer elemento de la lista que recibe

letra([ReslCuer],Res) !

% Estructura en modo de lenguaje natural los datos de la base de datos y la hace pregunta

haz-pregunta(A, Regresa) pregunta(Aj, write($ ? $), read-line(0, Opc), conv-min(Opc, Resp2), valida-resp(A, Resp2, Regresa).

haz-pregunta(A, $si$:).

% Verifica que el tercer argumento de la estructura corresponda a “pregu”

pregunta(Var) arg(3, Var, M), ifthenelse( M = pregu,

fail, write($$) ),

instan(Var).

% Verifica que la respuesta dada por el usuario se válida ( si o no)

valida-resp( A , Resp , Ret ) flush, ifthenelse( (Resp = $si$; Resp = $no$),

Ret = Resp, da-error( A , Ret ) ).

53

% Mensaje de que no es válida la respuesta del usuario

da-error( A , Ret ) write('Respuesta no valida'), nl, flush, haz-pregunta( A , Ret ).

1 4 4 1 7 5

YO Estructura la información obtenida de la base de conocimientos para presentar una %respuesta al usuario

da-resuI( Y , Band ) escr-men( Y , Lista , Band ), separa-pal( Lista , $$ , Resul ), write(Resu1).

% Separa palabras de la lista

separa-pal( [ Lista I Cuerpo ] , Ant , Res ):- divide( Lista , $ $ , Listal ), concat( Ant , Listal , Lista2 ) , separa-pal( Cuerpo , Lista2 , Res ), ! .

separa_pal( [ ] , Res , Res) !

% Elimina los guiones bajos de los elementos de una lista obteniendo la estructura para hacer la búsqueda en la base de conocimientos

divide( [ ] , M , M ) !.

divide( Lista , Ant , Res ) not(string-search( $-$ , Lista , -)), concat( Lista , $ $ , Obt ), concat( Ant , Obt , Res), ! .

divide(Lista,Ant,Res) string-search( !I-$ , Lista , Num ), substring( Lista , O , Num , Sublista ), concat( Sublista , $ $ , Obt ), concat( Ant , Obt , Listal ), string-length( Lista , Max), Long is Max - Num - 1, Min is Num + 1, substring( Lista , Min , Long , Var), !, divide( Var , Listal ~ Res ).

YO Transforma la estructura de la informacion obtenida de la base de conocimientos a un formato entendible para el usuario

escr-men( Var , L3 , Band ) functor( Var , Nom , -),

54

ifthenelse( Band = O, append( [ ] , [ Nom ] , Listal ), Listal = [ ] ),

arg(1 , Var , Suj ), append( Listal , Suj , Lista2 ), arg( 2 , Var , Com ), append( Lista2 , Com , L3 ).

YO Predicado que suma dos listas

append( [ 1 , 1-2 I L2 )

append([XILl],Lí!,[XIL]) :- !.

append( L1 , L2 , L) .

55

C o n c l u s i o n e s

CONCLUSIONES

En un principio el Proyecto se enfocó en la realización de un Sistema Experto de tipo diagnóstico, por Io que se investigaron las herramientas que existen para el apoyo y desarrollo de estos. Una de las herramientas utilizadas para la realización del mismo fué Prolog (lenguaje de programación lógica), tomandose cursos de este lenguaje, en donde se hicieron pequeños programas de prueba.

Analizando el comportamiento de este tipo de sistemas, se identificaron algunas de las partes que lo componen como son :

- Obtención de información de una Base de Conocimientos. - Un metodo para la alimentación de la misma. - Lograr que la informacion obtenida sea expresada de un modo más

- La capacidad de sistema de aprender de las experiencias que se entendible para el usuario.

le presenten.

Considerando a grandes rasgos las tareas que implican cada una de las partes anteriores se observó que no era posible el desarrollo total de un sistema de este tipo en el tiempo asignado, por lo que nos concentramos al desarrollo de Io que consideramos como partes básicas, que podrian ser útiles para la creacion posterior de sistemas mas completos. Estas partes son :

- INTERFAZ DE LENGUAJE NATURAL - LA ESTRUCTURACION Y ALIMENTACION DE LA BASE DE CONOCIMIENTOS

las cuales fueron desarrolladas por dos equipos por separado

En un principio las tareas de ambos equipos se consideraron independientes, elaborándose sin establecer una comunicación constante entre ellas con respecto a dudas y requerimientos que se presentaban, por lo que al probar el Sistema, se presentaron incompatibilidades entre las estructuras de ambas partes, generando errores que no permitieron el buen funcionamiento del mismo, lo cual implicó hacer modificaciones en ambas partes.

En el desarrollo de la lnterfaz de Lenguaje Natural, se tuvo que buscar la forma de presentar información al usuario con el lenguaje utilizado comunmente, por Io que se analizaron reglas y patrones que Io rigen. Observando que la cantidad de estructuras que lo componen es enorme, se tomó la decición que la estructura que más convenia es aquella que esta compuesta por: Sujeto(s), Verbo y Complemento(s), ya que es la forma básica por la cual reconocemos a un ente con sus calificativos.

Esta estructura se transformó a : verbo([sujeto(s)],[complemento(s)],identificador), para un manejo más accesible y una mejor representación en la base de conocimientos. Considerando que la lista de los calificativos a veces es muy extensa, se decidió identificar a esta lista con una etiqueta la cual seria sustituida por la información que le correspondiera al momento de dar un diagnóstico al usuario.

Continuando con el desarrollo de esta herramienta, fué necesario establecer la forma en que se obtendría la información de la base de conocimientos, identificando 3 tipos de información : a)La que nos llevaba a un diagnóstico final, para reconocer cuando se terminaba el encadenamiento del mismo b)La que fungia como encadenamiento, es decir, buscando en la base de conocimientos si la estructura que contiene la información puede llevarnos a obtener más información y as¡ sucesivamente c)La que proporcionaba la pauta para el comienzo de un diagnóstico, ya que sin este no se sabria en donde empezar a encadenar la información. Estos tres aspectos son diferenciados en la estructura bjsica por medio del campo del identificador.

Otro punto a desarrollar fué la forma de relacionar la información para obtener un diagnóstico y se encontró que la manera más adecuada es utilizar la de tipo condicional ya que permite obtener información de varias opciones, dada una condición, además de facilitar el encadenamiento hacia adelante el cual esta basado en aceptar o no aceptar cada una de las posibles respuestas que se le presenten, para as¡ poder obtener toda la

información que se necesita al dar un diagnóstico, basandose en lo siguiente :

- si A entonces B u - si B " entonces D u

conduciendonos a 9 A entonces D.

Dado lo anterior se estableció que para obtener la información de la base de conocimientos, se utilizaria la forma condicional.

Un punto al que nos enfrentamos al término del desarrollo del sistema fue el no poder crear su código ejecutable, ya que la versión manejada para el desarrollo de este, no presentaba esta facilidad, por lo que se intentó generar el código con una versión mas reciente. AI utilizar la nueva versión, se observá que no reconocia ventanas de presentacion, lo cual implicaba eliminarlas siendo no conveniente, ya que el sistema esta encaminado a la interacción con el usuario y es muy importante presentar un ambiente agradable para este.

Algunas de las sugerencias para el mejoramiento en el sistema son:

a) Basándonos en que el lenguaje que comunmente hablamos es muy extenso, es necesario establecer más estructuras para obtener una comunicación menos restringida con el usuario de la que en este trabajo se desarrolló. Dando un ejemplo tenemos: eliminar aquellas palabras que no son necesarias en la interpretación de un mensaje como son: los articulos, auxiliares que sirven para hacer preguntas, etc.

b) Representar la base de conocimientos en forma de predicados, la cual consiste en que una etiqueta contiene varias acciones con la cual se lograria el encadenamiento hacia adelante, necesitándose analizar cada parte de las acciones del predicado analizado.

BIBLIOGRAFIA.

Arity Corporation.

The ArityIExpert Development Package.

1986.

Arity Corporation.

The Arity/Prolog Language Reference Manual.

1988.

Ivan Bratko.

Prolog Programming For Artificial Intelligence.

1986.

Apuntes de conferencia de Sistemas Expertos

impartida en el Colegio Civil de Arquitectos

por la Profesora Susana Herrera Lima

cbl148.206.53.84/tesiuami/uam8561.pdf · 1.4.- desarrollo de un sistema experto - adquisición de...

Documents