Inteligencia Artificial

CUADERNO

DE TRABAJO

Inteligencia Artificial

Profesor

Mag. Eduardo F. Alonso Pérez

Febrero 2012

ÍNDICE DE FIGURAS ......................................................................... 6

ÍNDICE DE TABLAS ........................................................................... 7

INTRODUCCIÓN ................................................................................. 9

CAPÍTULO I: INTRODUCCIÓN A LA INTELIGENCIA ARTIFICIAL..10

1.1 Enfoques de los sistemas inteligentes. ......................................10

1.2 Prueba de Turing .......................................................................11

1.3 Fundamentos de la Inteligencia Artificial ....................................12

1.4 Historia de la Inteligencia Artificial .............................................13

1.5 Aplicaciones de la Inteligencia artificial ......................................14

CAPÍTULO II: AGENTES ...................................................................16

2.1 Agentes inteligentes ..................................................................16

2.2 Programa para un agente ..........................................................17

2.3 Tipos de programas para Agentes .............................................18

2.4 Agentes Reactivos .....................................................................19

2.5 Ejemplo de un Agente Reactivo (robot) .....................................20

2.6 Percepción y Acción ..................................................................21

2.7 Implementación del agente Reactivo Robot...............................22

2.8 Código completo en Visual Basic ..............................................24

CAPÍTULO III: RESOLUCIÓN DE PROBLEMAS MEDIANTE BÚSQUEDAS ....................................................................................27

3.1 Agente resolvente-Problemas ....................................................27

3.2 Mundo de la Aspiradora .............................................................29

3.3 Estrategia de búsqueda .............................................................30

3.4 Algoritmo general de búsqueda .................................................31

3.5 Búsqueda Ciega (no informada) ................................................32

3.5.1 Búsqueda Primero en Anchura ............................................32

3.5.2 Búsqueda de Costo Uniforme ..............................................32

3.5.3 Búsqueda Primero en Profundidad ......................................32

3.5.4 Búsqueda de Profundidad Limitada .....................................32

3.5.5 Búsqueda Primero en Profundidad con Profundidad Iterativa .....................................................................................................33

3.5.6 Búsqueda Bidireccional .......................................................33

3.6 Búsqueda Heurística (informada) ..............................................33

3.6.1 Búsqueda Voraz (Avara) Primero el Mejor ..........................33

3.6.2 Búsqueda A* Primero el Mejor .............................................34

3.6.3 Otros algoritmos ..................................................................34

CAPÍTULO IV: SISTEMAS EXPERTOS ............................................35

4.1 Introducción ...............................................................................35

4.2 Sistemas clásicos y sistemas expertos ......................................35

4.3 Breve historia.............................................................................36

4.4 Importancia de los sistemas expertos ........................................37

4.5 Inconvenientes de los sistemas expertos ..................................38

4.6 Arquitectura de un sistema experto ...........................................38

4.7 Base de conocimientos ..............................................................39

4.7.1 Reglas .................................................................................39

4.7.2 Atributos y valores ...............................................................40

4.7.3 Preguntas ............................................................................40

4.8 Motor de inferencia ....................................................................41

4.8.1 Encadenamientos ................................................................41

4.8.2 Algoritmo de Forward chaining ............................................42

4.8.3 Algoritmo de Backward chaining ..........................................45

4.8.4 Comparación de las dos estrategias ....................................48

4.8.5 Resolución de Conflicto .......................................................48

CAPÍTULO V: PROGRAMACIÓN LÓGICA .......................................50

5.1 Programación declarativa ..........................................................50

5.2 Programación lógica ..................................................................50

5.3 Breve historia del Prolog ............................................................51

5.4 Elementos principales del Prolog ...............................................51

5.4.1 Hechos ................................................................................52

5.4.2 Variables .............................................................................53

5.4.3 Reglas .................................................................................53

5.4.4 Consultas ............................................................................53

5.4.5 Ámbito de las variables ........................................................54

6.4.6 Mecanismo de control..........................................................54

5.5 Aplicación del Prolog a los Sistemas Expertos ..........................57

CAPÍTULO VI: RECONOCIMIENTO DE PATRONES .......................62

6.1 Introducción ...............................................................................62

6.2 Algunas aplicaciones .................................................................62

6.3 Conceptos básicos ....................................................................63

6.3.1 Objetos admisibles, clases, rasgos ......................................63

6.3.2 Descripción estándar de un objeto ......................................64

6.3.3 Función de comparación de rasgos .....................................64

6.3.4 Función de semejanza .........................................................64

6.3.5 R-uplo de Pertenencia de O ................................................64

6.3.6 Información Estándar de Clases ..........................................64

6.3.7 Matriz de aprendizaje (de control ó muestra) .......................65

6.4 Problemas que abarca el reconocimiento de patrones ..............66

6.4.1 Clasificación supervisada ....................................................66

6.4.2 Selección de rasgos ............................................................66

6.4.3 Clasificación no supervisada (agrupamiento ó clustering). ..66

6.5 Algoritmo NN (Nearest Neighbour). Clasificación Supervisada ..67

6.6 Algoritmo K-NN (K-Nearest Neighbour). Clasificación Supervisada ....................................................................................69

6.7 Algunas funciones de distancia .................................................70

6.8 Análisis Discriminante. Clasificación Supervisada .....................70

6.8.1 Funciones discriminantes ....................................................70

6.8.2 Puntuaciones Discriminantes ...............................................71

6.8.3 Coeficientes de las funciones ..............................................71

6.8.4 Aprendizaje .........................................................................72

6.8.5 Clasificación ........................................................................73

6.9 Prototipos. Clasificación Supervisada ........................................73

6.9.1 Idea general de los métodos................................................73

6.9.2 Algoritmos de prototipos ó centroides ..................................74

6.9.3 Algoritmo de Medios o Centros ............................................75

6.9.4 Algoritmo de Convexos ........................................................75

6.9.5 Clasificación ........................................................................76

6.9.6 Implementación del Algoritmo: Medios ó Centros ................76

CAPÍTULO VII: REDES NEURONALES ARTIFICIALES ..................79

8.1 Introducción ...............................................................................79

8.2 Breve historia de las RNA ..........................................................79

8.3 Algunas aplicaciones de las RNA: .............................................80

8.4 Neuronas biológicas ..................................................................80

8.5 Neuronas artificiales ..................................................................81

8.6 Especificación de una RNA .......................................................82

8.7 Clasificación general de las RNA ...............................................83

8.8 Modelos de neurona (Funciones de transferencia) ....................83

8.9 Topologías de RNA ...................................................................84

8.10 Aprendizaje supervisado. Perceptrón ......................................90

8.10.1 Aprendizaje de las RNA .....................................................90

8.10.2 Red Perceptrón .................................................................90

8.10.3 Modelo de neurona del Perceptrón ....................................91

8.10.4 Topología del Perceptrón ..................................................91

8.10.4 Regla de aprendizaje del Perceptrón .................................92

8.10.5 Algoritmo general de aprendizaje ......................................92

8.10.6 Limitación del Perceptrón ..................................................96

8.11 Aprendizaje no supervisado. Redes competitivas ....................96

8.11.1 Introducción .......................................................................96

8.11.2 Breve historia .....................................................................96

8.11.3 Redes Competitivas...........................................................97

8.11.4 Red de Kohonen ................................................................97

8.11.5 Topología ..........................................................................98

8.11.6 Etapa de Aprendizaje (no supervisado) .............................98

8.11.7 Algoritmo de Aprendizaje ...................................................99

REFERENCIAS ................................................................................ 101

ÍNDICE DE FIGURAS

Figura 1. Elementos de un agente ......................................................16

Figura 2. Entorno del Robot ................................................................20

Figura 3. Entradas del Robot ..............................................................21

Figura 4. Percepción y Acción ............................................................21

Figura 5. Variables sensoriales ..........................................................22

Figura 6. Entorno del Robot en Excel .................................................23

Figura 7. Mundo de la Aspiradora .......................................................29

Figura 8. Grafo de Transiciones. Aspiradora ......................................29

Figura 9. Arquitectura de un Sistema Experto ....................................39

Figura 10. Representación de una Regla ...........................................42

Figura 11. Arquitectura de un Sistema de Reconocimiento de Patrones

.....................................................................................................62

Figura 12. Ejemplos de objetos agrupados en 3 clases .....................65

Figura 13. Objeto de clase desconocida .............................................66

Figura 14. Objetos sin agrupar ...........................................................67

Figura 15. Conjuntos de objetos y sus clases .....................................68

Figura 16. Problema del algoritmo NN ................................................69

Figura 17.Centroides ..........................................................................74

Figura 18. Neurona Biológica .............................................................81

Figura 19. Neurona Biológica y Neurona Artificial ...............................81

Figura 20. Elementos de una neurona artificial ..................................82

Figura 21. Clasificación de redes neuronales .....................................83

Figura 22. Neurona Simple .................................................................84

Figura 23. Red Simple ........................................................................85

Figura 24. Red con elementos de asociación .....................................85

Figura 25. Red multicapa ....................................................................86

Figura 26. Modelo interactivo .............................................................86

Figura 27. Topología de la Red para el Robot ....................................87

Figura 28. Pesos entra la capa de entrada y la intermedia .................87

Figura 29. Pesos entre la capa intermedia y la de salida ....................89

Figura 30. Topología del Perceptrón ..................................................92

Figura 31. Objetos en R2, separados en 2 clases ..............................94

Figura 32. Red final. Perceptrón .........................................................96

Figura 33. Topología de la Red de Kohonen ......................................98

ÍNDICE DE TABLAS

Tabla 1. Enfoques de los sistemas inteligentes ..................................10

Tabla 2. Historia de la inteligencia artificial .........................................13

Tabla 3. Ejemplos de REAS ...............................................................17

Tabla 4. Tipos de programas de agente .............................................18

Tabla 5. Sistemas Clásicos vs Sistemas Expertos .............................35

Tabla 6. Paso Inicial. Forward Chaining .............................................43

Tabla 7. Primera Iteración. Forward Chaining ....................................43

Tabla 8. Segunda Iteración. Forward Chaining ...................................44

Tabla 9. Tercera Iteración. Forward Chaining .....................................44

Tabla 10. Cuarta Iteración. Forward Chaining ....................................44

Tabla 11. Quinta y última Iteración. Forward Chaining .......................45

Tabla 12. Paso Inicial. Backward Chaining .........................................46

Tabla 13. Primera Iteración. Backward Chaining ................................47

Tabla 14. Segunda Iteración. Backward Chaining ..............................47

Tabla 15. Cuarta y última Iteración. Backward Chaining .....................48

Tabla 16. Comparación entre las estrategias .....................................48

Tabla 17. Ejemplos de frases y hechos ..............................................52

Tabla 18. Preguntas, Consultas y Respuestas ...................................54

Tabla 19. Matriz de Aprendizaje .........................................................68

Tabla 20. Distancia del objeto desconocido a la muestra ...................69

Tabla 21. Matriz de Aprendizaje para el Análisis Discriminante ..........72

Tabla 22. Funciones Discriminantes ...................................................73

Tabla 23. Modelos de Redes Neuronales ...........................................83

INTRODUCCIÓN

La investigación y desarrollo tecnológico en Inteligencia Artificial ha contribuido con un conjunto de tecnologías poderosas que apoyan a las empresas e instituciones para resolver problemas relacionados con el manejo del conocimiento y en la toma de decisiones. Por otro lado, se tiene un gran avance en lo que se refiere a las tecnologías de la información, por lo cual el desarrollo e implementación de sistemas inteligentes son tareas fundamentales de cualquier institución. Este curso tiene como objetivo ofrecer una visión de las técnicas de Inteligencia Artificial (IA) como una herramienta de solución de problemas complejos. Presenta una perspectiva general de los apartados más significativos de la IA mostrando las bases, herramientas teóricas y las aplicaciones prácticas de esta rama de las tecnologías de la información. Para ello se estudian los aspectos básicos teóricos que sirven para desarrollar aplicaciones de IA relacionados con la búsqueda de soluciones, los sistemas expertos, el reconocimiento de patrones y las redes neuronales artificiales.

CAPÍTULO I: INTRODUCCIÓN A LA INTELIGENCIA ARTIFICIAL

La Inteligencia Artificial es un campo de la ciencia que trata de realizar, con máquinas, tareas que pueden ser realizadas por el hombre, aplicando cualquier tipo de razonamiento [1]. En cierta media cualquier programa de computador puede considerarse inteligente. El problema es diferenciar entre lo que se considera un “programa inteligente” y el que no lo es. Un programa inteligente es aquel que exhibe un comportamiento similar al humano cuando se enfrenta a un problema idéntico.

1.1 Enfoques de los sistemas inteligentes.

En la Tabla 1 se muestran cuatro enfoques de los sistemas inteligentes [1].

Tabla 1. Enfoques de los sistemas inteligentes

Sistemas que PIENSAN como humanos

Sistemas que PIENSAN racionalmente

“El nuevo y exitante esfuerzo de hacer que los computadores piensen” “La automatización de actividades que vinculamos con procesos de pensamiento humano, actividades como la toma de decisiones, resolución de problemas, aprendizaje..”

“El estudios de las facultades mentales mediante el uso de modelos computacionales” “El estudio de los cálculos que hacen posible percibir, razonar y actuar”

Sistemas que ACTÚAN como humanos

Sistemas que ACTÚAN racionalmente

“Desarrollar máquinas con capacidad para realizar funciones que cuando son realizadas por personas requieren de inteligencia” “El estudio de cómo lograr que los computadores realicen tareas, que por el momento, los humanos hacen mejor”

“La inteligencia Computacional es el estudio del diseño de agentes inteligentes” “Está relacionada con conductas inteligentes en artefactos”

Pensar como un humano Es necesario contar con un mecanismo para determinar cómo piensan los humanos. Una vez que se tenga una teoría al respecto, se podrá expresar esa teoría en la forma de un programa de computadoras. Si los datos de E/S y los tiempos de reacción del programa son similares a los de un humano existe la evidencia de que algunos de los mecanismos del programa se pueden comparar con los del los humanos. Ciencia cognitiva: Convergen

modelos computacionales de IA y técnicas experimentales de psicología intentando elaborar teorías precisas y verificables sobre el funcionamiento de la mente humana. Pensar racionalmente Intentar codificar la “manera correcta de pensar”. Un proceso de razonamiento irrefutable. Aristóteles fue uno de los primeros, a través de sus silogísmos (esquemas de estructuras de argumentación en las que siempre se llega a conclusiones correctas si partimos de premisas correctas). Lógica. Notación precisa para definir sentencias sobre todo tipo de elementos del mundo y especificar relaciones entre ellos. Ya en 1965 habían programas que resolvían cualquier problema que pudiera expresarse mediante la notación de la lógica. No es fácil transformar conocimiento informal y expresarlo en términos formales, sobre todo cuando el conocimiento es inferior al 100%. Es diferente a resolver un problema “en principio” y hacerlo en la práctica. Hay problemas que aún con unos pocos datos pueden agotar los recursos computacionales. Actuar racionalmente Un enfoque basado en agentes. Algo que razona. Los agentes informáticos se deben distinguir de los programas convencionales. Perciben su entorno. Persisten en el tiempo. Se adaptan a los cambios y son capaces de alcanzar objetivos diferentes. Un agente racional actúan con la intención de alcanzar el mejor resultado, ó cuando hay incertidumbre, el mejor resultado esperado. Las habilidades que se necesitan en la prueba de Turing deben permitir emprender acciones racionales. Es necesario contar con la capacidad para representar el conocimiento y razonar basándonos en él. El enfoque de la IA basados en las leyes del pensamiento pone todo el énfasis en hacer inferencias correctas, lo cual podría considerarse como racional. Sin embargo una inferencia correcta no depende siempre de la racionalidad. Hay situaciones en las que no hay nada correcto que hacer y es necesario tomar una decisión También hay maneras de actuar racionalmente que no implican realizar inferencias

1.2 Prueba de Turing

Fue propuesta por Alan Turing en 1950 [2]. Proporciona una definición operacional y satisfactoria de Inteligencia. Está basada en la incapacidad de diferenciar entre entidades artificiales y seres humanos. En la actualidad, programar una computadora para que supere la prueba requiere un trabajo considerable. El computador supera la prueba si un evaluador humano no es capaz de distinguir si las respuestas a una serie de preguntas, son de una persona ó no. Capacidades que debe tener la computadora Procesamiento de lenguaje natural: Para poder comunicarse satisfactoriamente en lenguaje natural. Representación del conocimiento: Para almacenar lo que se conoce ó siente. Razonamiento automático: Para utilizar el conocimiento almacenado para responder a preguntas y extraer nuevas conclusiones. Aprendizaje automático: Para adaptarse a nuevas circunstancias y para detectar y extrapolar patrones. Visión computacional: Para percibir objetos

Robótica: Para manipular y mover objetos La prueba se conserva vigente en la actualidad. Los científicos han dedicado poco esfuerzo a la evaluación de los sistemas con la prueba de Turing. Es mas importante el estudio de los principios en que se basa la inteligencia que duplicar un ejemplar. Los hermanos Wright tuvieron éxito en la búsqueda de un artefacto que volara, cuando dejaron de imitar a los pájaros y comprendieron los principios de la aerodinámica

1.3 Fundamentos de la Inteligencia Artificial

La Inteligencia Artificial tiene sus fundamentos en las siguientes áreas de conocimiento [1]

Filosofía Matemáticas Economía Neurociencia Psicología Ingeniería Computacional Teoría del Control y la Cibernética Lingüística

Filosofía ¿Existen reglas formales para extraer conclusiones válidas?. ¿Cómo se genera la inteligencia mental? ¿De donde viene el conocimiento? ¿Cómo se pasa del conocimiento a la acción? Silogísmos: Aristóteles. Extracción de conclusiones mecánicamente a partir de premisas iniciales). Dualismo: Descartes. Existe una parte de la mente que está al margen de la naturaleza. Los animales no poseen esta cualidad dual; e igualmente a las máquinas) Materialismo: Las operaciones del cerebro realizadas de acuerdo con las leyes de la física constituyen la mente). Empírico: Nada existe en la mente que no haya pasado por los sentidos. Inducción: Las reglas generales se obtienen mediante la exposición a asociaciones repetidas entre sus elementos. Positivismo lógico: Todo el conocimiento se puede caracterizar mediante teorías lógicas relacionadas. Teoría de la confirmación: Intenta explicar cómo el conocimiento se obtiene a partir de la experiencia. Matemáticas ¿Qué reglas formales seguir para obtener conclusiones válidas? ¿Qué se puede computar? ¿Cómo razonamos con incertidumbre?. Lógica formal: Desarrollo matemático a través de la lógica proposicional ó Booleana. Algoritmo: El primer algoritmo trivial fue el Euclídeo para calcular el mcd. Algoritmos para realizar deducciones lógicas. Teorema de incompletitud: En cualquier lenguaje que tuviera la capacidad para expresar las propiedades de los números naturales, existen aseveraciones verdaderas no decidibles (no se pueden validar mediante algoritmos). Intratabilidad: Problemas en los que el tiempo necesario para la resolución de los casos particulares crecen exponencialmente con el tamaño de los casos. NP-Completitud: Método para identificar problemas intratables.. Probabilidad: Ayuda al tratamiento de mediciones con incertidumbre Economía ¿Cómo tomar decisiones para maximizar rendimiento?. Teoría de la decisión: Combina la teoría de la probabilidad con la teoría de la utilidad. Teoría de juegos: En algunos juegos,

un agente racional debía actuar de forma aleatoria, o al menos, aleatoria en apariencia con respecto a sus contrincantes. Investigación operativa: Orienta a la optimización y toma de decisiones de dirección complejas. Satisfacción: Toma de decisiones que son “suficientemente buenas” Neurociencia ¿Cómo procesa información el cerebro?. Neurociencia: Estudio del sistema neurológico y en especial el cerebro. La forma exacta en que el cerebro genera los pensamientos. Neuronas: El cerebro está formado por células nerviosas llamadas neuronas que han sido observadas y estudiadas individualmente Psicología ¿Cómo piensan y actúan los humanos y los animales?. Conductismo: Rechaza cualquier teoría en la que intervengan procesos mentales. Insistieron en el estudio exclusivo de mediciones objetivas de percepciones (estímulos) y de las acciones resultantes (respuestas). Psicología cognitiva: Conceptualización del cerebro como un dispositivo de procesamiento de información. Pone énfasis en que la percepción entraña cierto tipo de inferencia lógica inconsciente. Ciencia cognitiva: Utilización de modelos informáticos para modelar la psicología de la memoria, el lenguaje y el pensamiento lógico Ingeniería Computacional ¿Cómo se puede construir un computador eficiente?. Computadora: La IA necesita además de Inteligencia y un Artefacto (la computadora). Hardware: Cada generación de dispositivos ha conllevado a un aumento en la velocidad de proceso y capacidad de almacenamiento. Software: Los Sistemas operativos, los lenguajes de programación y las herramientas modernas para escribir programas. La investigación en IA ha generado numerosas ideas importantes: Tiempo compartido, intérpretes imperativos, interfases gráficas, entornos de desarrollo rápido, programación simbólica, funcional, dinámica, orientada a objetos. Teoría del Control y cibernética ¿Cómo pueden los artefactos operar bajo su propio control?. Teoría del control: Ver el comportamiento determinista como algo emergente de un mecanismo regulador que intenta minimizar el “error” (la diferencia entre el estado actual y el objetivo). Cibernética: Modelos cognitivos matemáticos y computacionales. Función objetivo: Teoría del control moderna, basados en diseñar sistemas que maximizan una función objetivo en el tiempo. Lingüística ¿Cómo está relacionado el lenguaje con el pensamiento?. Lingüística computacional: Convergencia entre la lingüística moderna y la IA (procesamiento de lenguaje natural)

1.4 Historia de la Inteligencia Artificial

La Tabla 2 muestra una breve historia de la inteligencia artificial, resaltando las fechas y algunos de los hechos más detacados [2].

Tabla 2. Historia de la inteligencia artificial

Período Hechos más destacados Período de Gestación Los Modelos de neuronas artificiales (1943), Reglas

(1943-1956)

de actualización de aprendizaje (1949), Programas de ajedrez para computadoras (1950,1953), Primera computadora para simular una red de 40 neuronas a partir de un computador de tubos de vacío (1951), Lenguaje LISP. Primer lenguaje de IA (1958), Reunión en el Darmouth College (1956), Programa capaz de demostrar teoremas de lógica, Aparece por primera vez el término: “Inteligencia Artificial”.

Entusiasmo y grandes expectativas (1952-1965)

GPS. Solucionador general de problemas. Aborda un problema como un conjunto de subproblemas y posibles cursos de acción. Juego de damas con aprendizaje de la experiencia de las partidas jugadas (1952) Contribuciones de McCarthy en el MIT. LISP Compartido y desarrollo del EC (programa que incorpora conceptos de representación y conocimiento) (1958) Contribuciones de McCarthy en Stanford. Sistema de planificación y respuesta de preguntas (1969). Solución a problemas limitados (micromundos ANALOGY: analogía geométrica)

Dosis de Realidad (1966-1974)

Se predijo que en 10 años habría una máquina inteligente Teoría de NP-Completos. Programa ELIZA, en el MIT, que simulaba el comportamiento de un psicoanalista (1965) Experimentos en Machine Evolution (ahora llamados algoritmos genéticos). Perceptrones. Tipo de redes neuronales (1969)

Sistemas basados en conocimientos (1969-1979)

Dendral. Sistema para inferir estructuras moleculares. Mycin. Sistema para el diagnóstico médico de enfermedades sanguíneas. Se modela la incertidumbre. HPP. Proyecto de programación heurística. SHDRLU. Sistema para la comprensión del lenguaje natural. Lenguaje PROLOG (1972)

IA como industria (1980-1988)

R1. Primer sistema experto comercial, para la elaboración de pedidos. Proyecto de quinta generación en Japón (máquina PROLOG). Máquinas optimizadas para ejecutar LISP. Se produce un impacto industrial en los campos como la robótica y la visión artificial.

Regreso a las redes neronales (1986-presente).

Hopfield. Rumelhart y Hinton. Nuevos modelos de RN. - Reconocimiento de voz (HMM). Incertidumbre (Bayes). Robótica. Aprendizaje. Realidad virtual.

1.5 Aplicaciones de la Inteligencia artificial

Tratamiento de lenguaje natural Sistemas Expertos

Demostración de teoremas Robótica Programación automática Problemas de planificación Reconocimiento de patrones Manejo de incertidumbre Resolución de problemas Visión artificial

CAPÍTULO II: AGENTES Un agente es todo aquello que puede considerarse que percibe su ambiente mediante sensores y que responde o actúa en tal ambiente por medio de efectores [3], tal como se muestra en la Figura 1.

Figura 1. Elementos de un agente

Ejemplo de un agente natural:

Agente: cuerpo biológico Entorno: naturaleza Sensores: ojos, oídos, lengua, piel, etc. Efectores: piernas, brazos, manos, etc. Medida de rendimiento: sobrevivir, reproducirse,

Ejemplos de agentes artificiales

Agentes hardware (robots) Interactúan directamente con un entorno físico Disponen de un “cuerpo” físico Sensores: cámaras, telémetros infrarojos, etc. Efectores: ruedas/piernas, manipuladores, etc.

Agentes software (softbots): Actúan en entornos virtuales (p.e. Internet) Todo software: no necesitan manipular físicamente el entorno Sensores y efectores: dependientes del entorno

2.1 Agentes inteligentes

Se definen bajo en el enfoque de Agentes Racionales [3]. Actúan de forma racional en su entorno. Un agente racional es el que percibe y actúa para cumplir con sus objetivos con base a sus creencias de lo que es correcto. La racionalidad de un agente depende de cuatro factores:

La medida del rendimiento: define el grado de éxito del agente en el cumplimiento de sus objetivos. La secuencia de percepciones: todo lo que ha percibido el agente hasta ese momento. El conocimiento del medio: todo el conocimiento que ha acumulado en el medio en que habita. Las acciones que el agente puede ejecutar. El comportamiento racional de un agente es el que realiza a partir de la secuencia de percepciones hasta el momento, y el conocimiento a priori sobre el entorno y además elige entre las capacidades, la acción que maximice la medida de rendimiento. Adicionalmente otras características de los agentes racionales son la autonomía: Cuanto más se rige su comportamiento por su propia experiencia y cuanto menos depende de sus conocimientos a priori). Y el aprendizaje: Cuando no sólo recopila información, sino que aprende de lo que percibe Entorno de trabajo de los agentes (REAS)

Rendimiento ó metas Entorno ó ambiente Actuadores ó acciones Sensores ó percepciones

En la Tabla 3 se muestran algunos ejemplos de REAS para varios tipos de agentes:

Tabla 3. Ejemplos de REAS

2.2 Programa para un agente

Es una función que, a partir de las percepciones del agente, le permite realizar las acciones. El trabajo de la Inteligencia Artificial es diseñar el programa del agente. Se ejecuta en algún dispositivo de cómputo, el cual es llamado arquitectura.

2.3 Tipos de programas para Agentes

La Tabla 4, muestra cuatro tipos de programas de agente y sus principales características.

Tabla 4. Tipos de programas de agente

Tipo de Agente Características

Agentes reactivos (reflejo) simple

Este tipo de agente no contiene internamente estados y sus procesos o acciones que realiza son respuestas a la entrada de percepciones. Ignoran las percepciones históricas

Agentes reactivos basados en modelos (con estado interno)

Este tipo de agente guarda estados internos sobre la historia percibida lo cual le sirve para ejecutar una acción. Los sensores no nos pueden informar a la vez de todos los estados que maneja nuestro ambiente, es por este caso que el agente necesita actualizar algo de información en el estado interno.

Agentes basados en metas (u objetivos) Además de los estados, los agentes necesitan cierto tipo de información sobre sus metas Estas metas van a detallar las situaciones a las que se desea llegar de este modo, el programa de agente puede combinar las metas con la información de los

resultados (acciones) que emprenda y de esta manera poder elegir aquellas acciones que permitan alcanzar la meta

Agentes basados en utilidad

Utiliza un modelo del mundo, junto con una función de utilidad que calcula sus preferencias entre los estados del mundo. Después selecciona la acción que le lleve a alcanzar la mayor utilidad esperada, entre todos los resultados posibles

2.4 Agentes Reactivos

Los agentes reactivos se basan en tres ideas claves [3]: 1. No existe una especificación o plan a priori del comportamiento del agente reactivo. La dinámica de la interacción conduce a una alta complejidad. 2. Descomposición en tareas. Un agente reactivo es visto como una colección de módulos que operan en forma autónoma y son responsables de tareas específicas (sensar, controlar el motor, efectuar cálculos, etc.). La comunicación entre los módulos es mínima y de muy bajo nivel. 3. Tienden a operar sobre representaciones bien conocidas por los sensores, en contraste a las representaciones simbólicas de alto nivel que abundan en otros tipos de agentes.

2.5 Ejemplo de un Agente Reactivo (robot)

Un robot que se encuentra en un espacio bidimensional dividido en cuadrículas (Figura 2). Este robot esta limitado por una frontera, dentro de la cual hay también objetos inmóviles (no existen caminos cuyo ancho sea menor a dos cuadrículas) [1]. El robot debe seguir la siguiente pauta de comportamiento: Ir a una celda fronteriza, o que limite con un objeto, y seguir su perímetro indefinidamente. El robot debe ser capaz de percibir si una determinada celda esta libre para ser ocupada o no, y para ello debe llevar a cabo acciones

Figura 2. Entorno del Robot

El robot puede percibir si las (8) celdas que lo rodean están libres o no (Figura 3). Estas ocho entradas sensoriales las llamaremos:

s1, s2, s3, s4, s5, s6, s7,s8 Estas variables tendrán el valor

0 si están vacías 1 si están ocupadas

Figura 3. Entradas del Robot

El robot puede moverse a una celda libre adyacente que esté en su misma fila o columna. Por tanto, existen 4 movimientos posibles:

Norte, mueve el robot hacia arriba Este, mueve el robot hacia la derecha. Sur, mueve el robot hacia abajo. Oeste, mueve el robot hacia la izquierda.

2.6 Percepción y Acción

Para realizar el diseño, lo común seria dividir el cálculo de una acción, a partir de las señales sensoriales, en dos fases distintas, como se muestra en la Figura 4. En la fase de procesamiento perceptual se genera un vector de características x (x1 , … xN ) y en la fase de cálculo de la acción se selecciona una acción teniendo en cuenta dicho vector. Los valores de este vector pueden ser números reales o bien categorías. Las características binarias constituyen un caso especial ya que pueden ser consideradas como características numéricas (0 , 1) o categorizadas (V o F).

Figura 4. Percepción y Acción

Percepción Las entradas sensoriales del robot están representadas por el valor de las variables: s1, s2,…,s8, por lo cual existen 265 combinaciones posibles de estos valores. En nuestro entorno, por las restricciones que hemos puesto hay muchas combinaciones que pueden ser descartadas. Por tanto definiremos cuatro carácterísticas binarias definidas sobre las variables sensoriales: x1. x2. x3, y x4 que resumirán los casos que se pueden presentar, ilustrados en la Figura 5.

s2 ó s3 = 1 s4 ó s5 = 1 s6 ó s7 = 1 s8 ó s1 = 1

Figura 5. Variables sensoriales

Acción Dadas las cuatro características definidas anteriormente, el siguiente paso es definir una función que, de dichas características, nos proporcione la acción adecuada para llevar a cabo la tarea del seguimiento de los bordes. Si ninguna de las características toma el valor uno (quiere decir que el robot percibe que todas las celdas alrededor están vacías), la acción pude ser moverse a cualquier lugar. Tomaremos que se mueva al norte. Si al menos una característica es 1, se aplicarán las siguientes reglas: Si x1=1 y x2=0, moverse al este Si x2=1 y x3=0, moverse al sur Si x3=1 y x4=0, moverse al oeste Si x4=1 y x1=0, moverse al norte

2.7 Implementación del agente Reactivo Robot

Se diseñará el ambiente de trabajo del robot en una hoja de cálculo Excel, como se muestrra en la Figura 6.

Figura 6. Entorno del Robot en Excel

La programación del agente se hará en Visual Basic (utlizando macros en Excel). Se necesitarán las siguientes variables y funciones Variables:

S(1..8) : Vector Sensor Valores iguales a 0 ó 1 (libre-ocupado) También puede ser booleanos

X(1..4): Vector Característica Valores booleanos false-true

E(1..M,1..N): Matriz con el diseño del Espacio Valores iguales a 0 ó 1 (libre-ocupado)

F, C: Posición actual del Robot (enteros). Fila y Columna

Funciones:

F_Sensor(f,c) Calcula el valor del vector S (Sensor) para la celda(f,c)

F_Carac() Calcula el valor del vector X (Características) a partir de la información del Sensor

F_Mover() Realizar la acción de calcular la nueva posición del robot, coordenadas F,C, a partir del vector de características X.

Pseudo código de las funciones: F_Sensor(f,c) Calcula el valor del vector S (Sensor) para la celda(f,c)

S(1) <- E(f-1,c-1) S(2) <- E(f-1,c)

S(3) <- E(f-1,c+1) S(4) <- E(f,c+1) S(5) <- E(f+1,c+1) S(6) <- E(f+1,c) S(7) <- E(f+1,c-1) S(8) <- E(f,c-1)

F_Carac() Calcula el valor del vector X (Características) a partir de la información del Sensor

X(1) <- S(2) = 1 OR S3(3) = 1 X(2) <- S(4) = 1 OR S3(5) = 1 X(3) <- S(6) = 1 OR S3(7) = 1 X(4) <- S(8) = 1 OR S3(1) = 1

F_Mover() Realizar la acción de calcular la nueva posición del robot, coordenadas F,C, a partir del vector de características X. Regla:

Si x1=1 y x2=0, moverse al este Pseudo código:

si X(1) = true AND X(2) = false entonces df <- 0 dc <- 1 finsi

. . . F <- F + df C <- C + dc

2.8 Código completo en Visual Basic

Dim S(1 To 8) As Integer

Dim X(1 To 4) As Integer

Dim F As Integer

Dim C As Integer

Sub DibujarRobot()

Cells(F, C) = "X"

Range(Cells(F, C), Cells(F, C)).Select

End Sub

Sub Macro1()

'

' Acceso directo: Ctrl+Mayús+I

'

F = ActiveCell.Row

C = ActiveCell.Column

DibujarRobot

End Sub

Function Celda(fc As Integer, cc As Integer) As Integer

Range(Cells(fc, cc), Cells(fc, cc)).Select

If Selection.Interior.ColorIndex <> xlNone Then

Celda = 1

Else

Celda = 0

End If

End Function

Sub Sensor()

S(1) = Celda(F - 1, C - 1)

S(2) = Celda(F - 1, C)

S(3) = Celda(F - 1, C + 1)

S(4) = Celda(F, C + 1)

S(5) = Celda(F + 1, C + 1)

S(6) = Celda(F + 1, C)

S(7) = Celda(F + 1, C - 1)

S(8) = Celda(F, C - 1)

End Sub

Sub Caracteristica()

If S(2) = 1 Or S(3) = 1 Then

X(1) = 1

Else

X(1) = 0

End If

If S(4) = 1 Or S(5) = 1 Then

X(2) = 1

Else

X(2) = 0

End If

If S(6) = 1 Or S(7) = 1 Then

X(3) = 1

Else

X(3) = 0

End If

If S(8) = 1 Or S(1) = 1 Then

X(4) = 1

Else

X(4) = 0

End If

End Sub

Sub Accion()

If X(1) = 1 And X(2) = 0 Then 'este/der

C = C + 1

Exit Sub

End If

If X(2) = 1 And X(3) = 0 Then 'sur/abajo

F = F + 1

Exit Sub

End If

If X(3) = 1 And X(4) = 0 Then 'oeste/izq

C = C - 1

Exit Sub

End If

If X(4) = 1 And X(1) = 0 Then 'norte/arriba

F = F - 1

Exit Sub

End If

'accion por defecto: norte

F = F - 1

End Sub

Sub Mover()

DibujarRobot

End Sub

Sub Macro2()

'

' Acceso directo: Ctrl+Mayús+M

'

Sensor

Caracteristica

Accion

Mover

End Sub

CAPÍTULO III: RESOLUCIÓN DE PROBLEMAS MEDIANTE BÚSQUEDAS Los agentes reactivos, explicados en el capítulo antrerior, basan sus acciones en la aplicación directa desde los estados a las acciones. No pueden funcionar bien en entornos en los que la aplicación sea demasiado grande para almacenarla [2].

3.1 Agente resolvente-Problemas

Los Agente Resolvente-Problemas deciden qué hacer para encontrar secuencia de acciones que conduzcan a los estados deseables. Formalmente un Agente Resolvente-Problemas se describe definiendo los siguientes aspectos:

Formulación del Objetivo Formulación del Problema Búsqueda Solución Ejecución Formulación del Objetivo Los objetivos ayudan a organizar el comportamiento, limitando las metas que debe alcanzar el agente. Ejemplo: Agente que está de viaje por una ciudad A. Los objetivos podrían ser muchos: Tomar fotos, disfrutar de la vida nocturna, conocer a los pobladores, etc, con lo cual las decisiones en cada momento son muy complejas. Ahora, supongamos que tiene un pasaje no reembolsable para viajar desde la ciudad B al día siguiente, entonces todas las acciones que no alcancen a B, se pueden rechazar, y el objetivo sería muy simple: Llegar a B (ó Estar en B) Formulación del Problema Es el proceso de decidir qué acciones y estados hay que considerar para alcanzar el objetivo formulado. Por ejemplo: Las acciones podría ser, viajar de una ciudad grande a otra, ó tomar las rutas mas cortas, etc. En este caso los estados serían el estar en una determinada ciudad. Supongamos que hay tres caminos que salen de A (a C, D y E), pero ninguno directo a B. Habrían dos posibilidades:

1) El agente no conoce la geografía del lugar, así que tendría que tomar cualquiera de las rutas ya que no sabría cual de las acciones es la más mejor. En este caso el agente no conoce lo suficiente los estados que resultan de tomar una acción.

2) El agente tiene un mapa que le brinda información sobre los estados en que podría estar, así como las acciones que podría tomar. Búsqueda Utilizando esa información puede encontrar un camino de A a B, y tomar las acciones que correspondan en cada momento. De esta manera alcanzaría su objetivo (Llegar a B). Un

agente decide qué hacer en cada estado examinando las diferentes secuencias posibles de acciones que le conducen a otros estados, para entonces escoger la mejor secuencia. Hallar esta secuencia es la Búsqueda. Solución Es la secuencia de acciones que devuelve un algoritmo de Búsqueda. El algoritmo de Búsqueda recibe como entrada un Problema y devuelve la Solución para alcanzar el Objetivo. Ejecución Una vez que tenemos la solución, se procede a ejecutar las acciones. A esta fase se le llama Ejecución. En la práctica para plantear la búsqueda de soluciones mediante este tipo de agentes se necesita definir: Espacio de estados Estado inicial Estado (o estados) final (es) Acciones posibles Grafo de transiciones Algoritmo de búsqueda de la solución Espacio de estados: El estado inicial y su Sucesor definen el espacio de estados del problema (todos los estados alcanzables desde el estado inicial). Se representa mediante un Grafo, en el que los nodos son los estados y los arcos las acciones. Estado Inicial (en el que comienza el agente) Estado (o estados) final (es). Son los estados a los cuales debe llegar el agente para indica que ha concluido la búsqueda. Acciones posibles. Se describen mediante una función Sucesor. Sucesor(X) es un conjunto de pares <acción,Y>. X y Y son estados. Grafo de transiciones: Es la representación de todos los estados y las transiciones de unos a otros mediante las acciones. Algoritmo de búsqueda de la solución: Estrategia para encontrar la solución. Otros términos: Camino: Secuencia de estados conectados por una secuencia de acciones Test Objetivo: Determina si un estado es Objetivo Costo del camino: Se asigna un costo numérico a cada camino. El agente R-P elige una función costo que refleje una medida de rendimiento. Por ejemplo, para el caso de las ciudades podría ser la distancia en kilómetros. Supondremos que el costo del camino se calcula sumando los costos individuales de las acciones a lo largo del camino: c( a, x, y ) Costo Individual de la acción a la cual nos lleva del estado x al y. Solución Óptima: La solución cuyo costo del camino es el mínimo entre todas las posibles soluciones. Veamos un ejemplo.

3.2 Mundo de la Aspiradora

Su función es limpiar las dos localizaciones sobre las cuales se puede mover [2]. Se puede observar en la Figura 7. Condiciones: Hay solo dos localizaciones (Izquierda y Derecha) Las localizaciones pueden estar limpias ó sucias En cada momento la aspiradora sabe dónde está y si hay suciedad ó no en cada lugar.

Figura 7. Mundo de la Aspiradora

Estados: Describen la ubicación de la aspiradora y la situación de las localizaciones (limpias ó sucias). Serían tres valores. En el caso del dibujo: 0-0-1 Estado inicial: Cualquiera Acciones: Desplazarse a la Izquierda, a la Derecha y Limpiar. Objetivo: Que no haya suciedad en ninguna de las celdas y la aspiradora esté cualquier localización. Estados objetivos: 0-0-0 ó 1-0-0 Espacio de solución. Es un grafo, que describe todos los posibles caminos que conducen a la solución del problema. Los vértices son los estados y las aristas son las acciones que conducen de un estado a otro. En este caso existen 2x2x2 = 8 estados (vértices) ya que hay dos posibilidades para cada componente de la descripción de los mismos. Las aristas unen a los estados de acuerdo a los resultados de las acciones aplicadas a cada estado. Las acciones serían las etiquetas de las aristas.

Figura 8. Grafo de Transiciones. Aspiradora

Para escoger los estados y las acciones se requiere de un proceso de la eliminación de detalles de una representación que se denomina Abstracción. Se debe abstraer tanto en la descripción del estado como en las acciones. El verdadero arte de la solución de problemas consiste en saber decidir que es lo servirá para describir los estados y acciones y qué no. Búsqueda Utilizando la información del espacio de solución (grafo), se puede encontrar un camino desde el estado inicial al estado final, realizando las acciones que correspondan en cada momento. Un agente decide qué hacer en cada estado examinando las diferentes secuencias posibles de acciones que le conducen a otros estados. Finalmente, después de realizar este proceso de exploración, encuentra una secuencia que lo conduce a la solución (objetivo). Hallar esta secuencia es la Búsqueda. Algoritmo de Búsqueda de Soluciones Durante la búsqueda de la solución el algoritmo va construyendo un árbol en el que se almacena, en cada nodo, información sobre los estados que se van obteniendo al realizar las acciones. La raíz del árbol se corresponde con el estado inicial. Sus hijos (otros estados) son los que resultan de realizar las acciones a ese estado. Se continua con la creación del árbol, aplicando el mismo razonamiento a cada hijo (sin repetir estados en cada camino), hasta que se llegue al estado final. Durante el proceso de construcción del árbol se utiliza una función que dado un Nodo (estado) obtiene los estados que resultan de realizar todas las acciones en ese estado. A esta operación le llamaremos Expandir. Debe expandir nodos que conduzcan a estados que no estén en el mismo camino. Esta función obtiene la información a partir del Grafo.

3.3 Estrategia de búsqueda

Criterio para elegir cuál será el siguiente estado a Expandir. Utiliza el concepto de Frontera. La Frontera son todos los nodos del árbol que han sido generados, pero no expandidos. Al comienzo, la frontera contiene únicamente a la raíz del árbol. La estrategia de búsqueda consistirá entonces en determinar, de la frontera, cuál será el siguiente nodo a expandir. En el caso de la estrategia Primero en profundidad la Frontera se implementa mediante una Pila. Para la estrategia de Primero en Anchura la Frontera se implementa mediante una Cola. Estrategias de búsquedas: No Informadas ó a Ciegas: Significa que no se tiene información adicional acerca de los estados. La única información es la que proporciona la formulación del problema. Sólo generan sucesores y distinguen si han llegado al objetivo ó no. Informadas ó Heurísticas: Estrategias en las que se sabe, cuando un estado no es objetivo, si es mas “prometedor” que otro. Estrategias de Búsquedas No Informadas (A ciegas): Búsqueda Primero en Anchura Búsqueda de Costo Uniforme

Búsqueda Primero en Profundidad Búsqueda de Profundidad Limitada Búsqueda Primero en Profundidad con Profundidad Iterativa Búsqueda Bidireccional Estrategias de Búsquedas Informadas (Heurísticas): Búsqueda Primero el Mejor Búsqueda A* Existen algunos criterios para evaluar las estrategias: Completitud: ¿La estrategia garantiza encontrar una solución, si es que esta existe? Complejidad en tiempo: ¿Cuánto tiempo se necesitara para encontrar una solución? Complejidad en espacio: ¿Cuánta memoria se necesita para efectuar la búsqueda? Optimización: ¿Con esta estrategia se encontrará una Solución Óptima?

3.4 Algoritmo general de búsqueda

Utiliza una Lista, para representar la frontera. Sobre la lista se necesitan las siguientes operaciones: Crear, Vacia?, Primero, EliminarPrimero, InsertarUno, InsertarTodos Utiliza una función Expandir que retorna todos los nodos resultantes de expandir uno determinado Pseudo código del algoritmo general funcion Busqueda_Arbol(problema) retorna Solución

Crear(frontera) ; lista vacia

InsertarUno(frontera,

NodoInicial(ESTADOINICIAL(problema)))

repetir

si Vacia?(frontera) retornar Solución Vacía

nodo <- EliminarPrimero(frontera)

si TEST_OBJETIVO(problema,nodo.Estado) es Verdadero

retornar SOLUCIÓN(nodo)

InsertarTodos(frontera,Expandir(nodo, problema))

fin funcion

funcion Expandir(nodo, problema) retorna Conjunto de Nodos

Crear(conjunto) ; vacio

sucesores <- SUCESOR(problema,nodo.Estado)

para cada <accion,resultado> en sucesores hacer

n <- nuevo nodo

n.Estado <- resultado

n.Padre <- nodo

n.Accion <- accion

n.CostoCamino <- nodo.CostoCamino +

CostoIndividual(nodo.estado,accion,n.estado)

n.Profundidad <- n.Profundidad + 1

adicionar(n,conjunto)

retornar conjunto

fin funcion

3.5 Búsqueda Ciega (no informada)

3.5.1 Búsqueda Primero en Anchura Es una estrategia de búsqueda sencilla. Se expande primero el nodo raíz, y luego todos los nodos sucesores de éste; a continuación todos los sucesores de éstos últimos y así sucesivamente. En general, se expanden todos los nodos de una misma profundidad, antes de expandir cualquier nodo del próximo nivel. Se puede implementar, mediante el Algoritmo General, considerando la Lista, como una Cola (cuyas operaciones de Inserción y Eliminación funcionan en forma FIFO (primero en entrar, primero en salir). De esta manera todos los nodos que se van generando a través de la expansión se van colocando al final de la Cola, garantizando esto que los nodos de un mismo nivel ó profundidad se expandan antes que los de un nivel más bajo ó mayor profundidad. Este tipo de búsqueda permitirá siempre encontrar primero el estado objetivo más próximo. Esta estrategia en general no es buena debido a la cantidad de tiempo y memoria necesaria para realizar una búsqueda 3.5.2 Búsqueda de Costo Uniforme En lugar de expandir el nodo más superficial, expande aquel que tiene menor costo en su camino. Mediante esta estrategia se puede encontrar la solución más barata siempre y cuando se satisfaga un requisito muy sencillo “costo de la ruta nunca debe ir disminuyendo conforme avanzamos por la ruta”. Notar que si todos los costos son iguales a 1, la estrategia se comporta similar a la de Primero en Anchura. Se puede implementar, mediante el Algoritmo General, considerando la Lista como una Cola de Prioridad, cuyo criterio para obtener el Primero (Eliminar) de la Cola sería el de menor Costo 3.5.3 Búsqueda Primero en Profundidad Esta búsqueda se centra en expandir un único camino desde la raíz. Siempre se expande el nodo más profundo en la frontera actual. En el caso de llegar a un “callejón sin salida” se retrocede hasta el nodo más cercano (siguiendo al nodo padre) donde se puede tomar una rama alternativa para poder seguir avanzando. Se puede implementar, mediante el Algoritmo General, considerando la Lista, como una Pila (cuyas operaciones funcionan en forma LIFO (último en entrar, primero en salir). De esta manera el siguiente nodo a expandir siempre será el último que se haya colocado en la pila de ese nivel, garantizando esto que la expansión vaya aumentando en la profundidad de los nodos. Es común aplicar esta estrategia mediante una algoritmo recursivo que recorra el árbol en Pre-Orden. Tiene modestos requisitos de memoria. Sólo necesita almacenar un camino, junto con los hermanos restantes no expandidos en cada nodo. 3.5.4 Búsqueda de Profundidad Limitada Similar a la estrategia de Primero en Profundidad, pero se trata de eliminar el problema de que se puedan general árboles “ilimitados”. Para ello establece un límite L a la

profundidad del árbol. Todo nodo cuya profundidad sea L, no es expandido (se considera sin sucesores). El problema que puede pasar es si escogemos un valor de L menor que la profundidad del Objetivo, en cuyo caso no llegaríamos a la Solución. 3.5.5 Búsqueda Primero en Profundidad con Profundidad Iterativa Combina la estrategia de Primero en Profundidad con la de Profundidad Limitada, comenzando con Límite igual a 0, aumentándolo de 1 en 1 hasta encontrar el objetivo. Combina las ventajas de las dos estrategias. 3.5.6 Búsqueda Bidireccional La idea es ejecutar dos búsquedas simultáneas: una hacia delante, desde el estado inicial y otra hacia atrás, desde el estado objetivo. La búsqueda termina cuando las dos búsquedas se encuentren (las búsqueda deben comprobar, antes de la expansión, si los nodos de sus fronteras coinciden)

3.6 Búsqueda Heurística (informada)

Utilizan conocimiento específico del problema, más allá de la definición del problema en sí mismo. Pueden encontrar la solución de manera más eficiente Estos algoritmos están basados en una función heurística h(n) h(n) = costo estimado del camino más barato desde el nodo n hasta el Objetivo La función heurística h(n) se una heurística admisible, significa que la función nunca sobreestime el costo de alcanzar el objetivo. Los dos algoritmos mas importantes de búsqueda informada son: Búsqueda Primero El Mejor - Búsqueda Voraz (Avara) - Búsqueda A* Búsqueda Primero el Mejor Es un caso particular del algoritmo general de búsqueda en Árboles en la cual se selecciona el siguiente nodo a expandir en base a una función de evaluación f(n). Esta función mide la “distancia” al objetivo. Se expande el nodo con la evaluación más baja. Se implementa de manera similar al método de “Búsqueda con Costo Uniforme”, mediante una cola de prioridad. La función de evaluación nos brinda el nodo que “parece” ser el mejor y por tanto el que se debe expandir. 3.6.1 Búsqueda Voraz (Avara) Primero el Mejor Expande el nodo más cercano al Objetivo, asumiendo que probablemente conduzca más rápidamente a la solución. La función de evaluación f(n) sería la función heurística h(n) f(n) = h(n) h(n) = costo estimado del camino más barato desde el nodo n hasta el Objetivo

El término Voraz ó Avara es porque en cada paso trata de ponerse tan cerca del objetivo como pueda, seleccionando el nodo con menor función de evaluación f(n). No necesariamente brinda la solución óptima (ver ejemplo de las ciudades). Al igual que los otros métodos estudiados es necesario verificar los “callejones sin salidas” (no exapandir estados repetidos) 3.6.2 Búsqueda A* Primero el Mejor El objetivo es minimizar el costo estimado total de la solución, para ello evalúa los nodos combinando g(n) y h(n) g(n): costo de haber alcanzado n h(n): costo para llegar desde n hasta el objetivo f(n) = g(n) + h(n) Costo más barato estimado de la solución a través de n La función f(n) combina el costo del camino para llegar a n y el costo estimado para llegar desde n al objetivo. En cada paso se expande el nodo con el valor más bajo de f(n), ó sea, de g(n)+h(n). 3.6.3 Otros algoritmos Búsqueda A* con Profundidad Iterativa (A*PI). Similar al algoritmo de profundidad iterativa, pero utilizando f(n) (g+h) como criterio de corte en cada iteración, en lugar de la profundidad. El valor del corte es el costo f(n) más pequeño de cualquier nodo que haya excedido el corte de la iteración anterior. Búsqueda recursiva del primero mejor (BRPM): Similar al algoritmo de primero el mejor, pero en un espacio lineal, sin almacenar todo el árbol, sino almacenando únicamente la pista del mejor valor f alternativo disponible desde cualquier antepasado del nodo actual. Si el nodo excede ese límite se regresa al camino alternativo.

CAPÍTULO IV: SISTEMAS EXPERTOS

4.1 Introducción

Los sistemas expertos constituyen un campo de la Inteligencia Artificial. Son programas que reproducen el proceso intelectual de un Experto Humano en un espacio de conocimientos limitado. En principios deben dar solución a un problema siguiendo los pasos que daría un experto humano [4]. Los principales objetivos para los cuales se crea un sistema experto son mejorar la productividad. Ahorrar tiempo, dinero. Conservar el conocimiento y difundirlo. Los sistemas expertos ofrece un extenso campo de posibilidades en resolución de problemas. Están ampliamente extendidos debido a su importante impacto en los negocios, la industria, la medicina, etc. Están diseñados para actuar como un especialista humano en un dominio ó área particular del conocimiento Constiuyen um intermediario entre el experto, que transmite el conocimiento al Sistema y el Usuario que lo utiliza para resolver un problema. Utilizan para su funcionameinto: -Conocimiento que tiene almacenado -Mecanismo de inferência Simultáneamente el usuario puede observar el comportamiento del Sistema . en el proceso de solución de un problema se representan los mecanismos Heurísticos de razonamiento del Experto. Un sistema experto contiene [5]:

El conocimiento almacenado (Base de Conocimiento) Programa que lo controla (Mecanismo de Inferencia) Datos propios del problema (Base de Hechos)

4.2 Sistemas clásicos y sistemas expertos

La Tabla 5, muestra una comparación entre los sistemas clásicos y los sistemas expertos.

Tabla 5. Sistemas Clásicos vs Sistemas Expertos

SISTEMA CLÁSICO SISTEMA EXPERTO

Conocimiento y procesamiento combinados en un programa

Base de conocimiento separada del mecanismo de procesamiento

No contiene errores Puede contener errores

No da explicaciones, los datos sólo se usan o escriben

Una parte del sistema experto la forma el módulo de explicación

Los cambios son tediosos Los cambios en las reglas son fáciles

El sistema sólo opera completo El sistema puede funcionar con pocas reglas

Se ejecuta paso a paso La ejecución usa heurísticas y lógica

Necesita información completa para operar

Puede operar con información incompleta

Representa y usa datos Representa y usa conocimiento

4.3 Breve historia

El primer resultado data de mediados de la década del 60. El GPS (General Problem Solver). Estaba limitado a problemas matemáticos. Se cambió el enfoque restringiendo el alcance a un dominio específico. Se trató de simular el razonamiento de un experto humano [4]. En 1965, un equipo liderado por Edward Feigenbaum, comenzó a desarrollar sistemas expertos utilizando bases de conocimiento muy específicas. En 1967 se construye DENDRAL, que se considera como el primer sistema experto. Se utilizaba para identificar estructuras químicas moleculares a partir de su análisis espectrográfico. Entre 1970 y 1980 se desarrolló MYCIN para consulta y diagnóstico de infecciones de la sangre. (Utilización de conocimiento impreciso para razonar y posibilidad de explicar el proceso de razonamiento) Con el MYCIN aparecen claramente diferenciados motor de inferencia y base de conocimientos. Apareció el término Sistema Vacío o Shell (concha). Así surgió EMYCIN (MYCIN Esencial) con el que se construyó SACON, utilizado para estructuras de ingeniería, PUFF para estudiar la función pulmonar y GUIDON para elegir tratamientos terapéuticos. En esa época se desarrollaron también: HERSAY, que intentaba identificar la palabra hablada, y PROSPECTOR, utilizado para hallar yacimientos de minerales. De este último derivó el shell KAS (Knowledge Adquisition System) A partir de 1980 se ponen de moda los sistemas expertos. Numerosas empresas de alta tecnología investigan en este área de la inteligencia artificial, desarrollando sistemas expertos para su comercialización. Con todas las experiencias se llega a la conclusión de que el éxito de un sistema experto depende casi exclusivamente de la calidad de su base de conocimiento. El inconveniente es que codificar la pericia de un experto humano puede resultar difícil, largo y laborioso

Aplicaciones de los sistemas expertos Son muy eficases cuando se tiene que analizar una gran cantidad de información, interpretándola y proporcionando una recomendación a partir de la misma. Análisis financiero: oportunidades de inversión, dependiendo de los datos financieros de un cliente y de sus propósitos. Detectar y reparar fallos en equipos electrónicos (diagnóstico y depuración de errores mediante listas de preguntas con las que obtienen los datos necesarios para llegar a una conclusión) Localizar problemas en sistemas informáticos grandes y complejos. Predecir resultados futuros a partir del conocimiento que tienen (Sistemas meteorológicos y de inversión en bolsa) Planificación (secuencia de acciones necesaria para lograr una meta). Gestionar proyectos de desarrollo, planes de producción de fábricas, estrategia militar y configuración de complejos sistemas informáticos, entre otros Controlar procesos tomando decisiones como respuesta a su estado y no existe una solución algorítmica adecuada (supervisión de fábricas automatizadas, factorías químicas o centrales nucleares. Estos sistemas son extraordinariamente críticos porque normalmente tienen que trabajar a tiempo real) Ayuda a los diseñadores a completar especificaciones y requisitos de forma competente y dentro de los límites de costes y de tiempo (circuitos electrónicos, circuitos integrados, tarjetas de circuito impreso, estructuras arquitectónicas, autos, piezas mecánicas, etc) Evaluar el nivel de conocimientos y comprensión de un estudiante, y ajustar el proceso de aprendizaje de acuerdo con sus necesidades

4.4 Importancia de los sistemas expertos

El acceso al conocimiento y al juicio de un experto es extremadamente valioso en muchas ocasiones (prospecciones petrolíferas, manejo de valores bursátiles, diagnóstico de enfermedades, etc.) En la mayoría de los campos de actividad existen más problemas por resolver que expertos para resolverlos. El sistema experto actuará como ayudante para los Expertos Humanos y como consultor cuando no se tiene otro acceso a la experiência. Mejora la productividad al resolver y decidir los problemas más rápidamente. Esto permite ahorrar tiempo y dinero. A veces sin esa rapidez las soluciones obtenidas serían inútiles. Los valiosos conocimientos de un especialista se guardan y se difunden, de forma que, no se pierden aunque desaparezca el especialista.

Se pueden utilizar personas no especializadas para resolver problemas. Una persona que utiliza regularmente un sistema experto aprenderá de él, y se aproximará a la capacidad del especialista. Se obtienen soluciones más fiables gracias al tratamiento automático de los datos, y más contrastadas, debido a que se suele tener informatizado el conocimiento de varios expertos Tienen gran flexibilidad debido a la separación entre la base de conocimiento y el mecanismo de inferência.

4.5 Inconvenientes de los sistemas expertos

El conocimiento humano es complejo de extraer y, a veces, es problemático representarlo Las estrategias de razonamiento de los motores de inferencia suelen estar programadas procedimentalmente y se adaptan mal a las circunstancias. Están limitados para tratar problemas con información incompleta. Un experto humano no estudia progresivamente una hipótesis, sino que decide de inmediato cuando se enfrenta a una situación análoga a otra ocurrida en el pasado. Los sistemas expertos no utilizan este razonamiento por analogía. Los costes y duración del desarrollo de un sistema experto son bastante considerables y su campo de aplicación es restringido y específico

4.6 Arquitectura de un sistema experto

Un sistema experto (Figura 9) está compuesto por [5]: Base de conocimientos (BC) Memoria de Trabajo (Base de Hechos y atributos calculados) (Memoria) Motor de inferencia (MI) Interfaz con el usuario (IU)(Módulo de explicación, Módulo de adquisición del conocimiento)

Figura 9. Arquitectura de un Sistema Experto

4.7 Base de conocimientos

La base de conocimientos contiene el conocimiento especializado extraído del experto en el domínio. El método más común para representar el conocimiento es mediante reglas de producción. 4.7.1 Reglas El dominio de conocimiento se divide en fracciones de conocimiento ó reglas de la forma SI . . . ENTONCES . . . Cada regla constará de una parte denominada condición (antecedente) y de una parte denominada acción (consecuente): SI condición ENTONCES acción Ejemplo: SI el termómetro marca 39º Y el termómetro funciona correctamente ENTONCES el paciente tiene fiebre La base de conocimientos es independiente del mecanismo de inferencia que se utiliza para resolver los problemas. Cuando los conocimientos almacenados se han quedado obsoletos, o cuando se dispone de nuevos conocimientos, es relativamente fácil añadir reglas nuevas, eliminar las antiguas o corregir errores en las existentes. No es necesario reprogramar todo el sistema experto. Las reglas suelen almacenarse en alguna secuencia jerárquica lógica, pero esto no es estrictamente necesario. Se pueden tener en cualquier secuencia y el motor de inferencia las usará en el orden adecuado que necesite para resolver un problema. Ejemplo (vehículos): Identificar vehículos: Regla 1: SI tiene 2 ruedas Y utiliza motor ENTONCES es una motocicleta Regla 2: SI tiene 2 ruedas Y es movido por el hombre ENTONCES es una bicicleta Regla 3: SI tiene 4 ruedas Y utiliza motor Y pesa menos de 3500 Kg ENTONCES es un auto

4.7.2 Atributos y valores La base de conocimiento debe expresarse en términos de Atributos y Valores. En el Ejemplo, los atributos y sus valores podrían ser: DOSRUEDAS (valor SI ó NO para indicar si el vehículo tiene 2 ruedas) MOTOR (valor SI ó NO para indicar si el vehículo utiliza motor) HOMBRE (valor SI ó NO para indicar si el vehículo es movido por el hombre) CUATRORUEDAS (valor SI ó NO para indicar si el vehículo tiene 4 ruedas) MENKG (valor SI ó NO para indicar si el vehículo pesa menos de 3500Kg) VEHICULO (valores MOTOCICLETA, BICICLETA y AUTO que indicarán el resultado del sistema experto) Las reglas, expresadas en términos de atributos y valores, serían: Regla 1: SI DOSRUEDAS='SI' Y MOTOR='SI' ENTONCES VEHICULO='MOTOCICLETA' Regla 2: SI DOSRUEDAS='SI' Y HOMBRE='SI' ENTONCES VEHICULO='BICICLETA' Regla 3: SI CUATRORUEDAS='SI' Y MOTOR ='SI' Y MENKG='SI' ENTONCES VEHICULO='AUTO' BASE DE CONOCIMIENTOS (PREGUNTAS) 4.7.3 Preguntas Durante el funcionamiento del sistemas experto, el módulo de Interfaz de Usuario requiere pedir información al Usuario. Concretamente el valor de los atributos que se desconocen y que no se pueden inferir por ninguna regla. Para ello realiza preguntas al usuario las cuales se especifican en la Base de Conocimientos. En el Ejemplo: DOSRUEDAS ='¿El vehiculo tiene 2 ruedas ? ' MOTOR='¿El vehiculo utiliza motor ? ' HOMBRE='¿El vehiculo es movido por el hombre ? ' CUATRORUEDAS ='¿El vehiculo tiene 4 ruedas ? ' MENKG='¿El vehiculo pesa menos de 3500Kg ? ' VEHICULO= '¿Cuál es el vehículo? ' De igual manera puede sugerir las posibles respuestas (SI, NO, etc) las cuales también estarían en la Base de Conocimientos Ejemplo (arranque auto): Conocimiento del experto: El auto no arranca. Puede ser la batería descargada la cual se puede verificar comprobando si funciona el Electrolito de la batería. También se puede verificar si funciona al medirla con el Voltímetro. Si es la batería descargada la reparación es “Cambiar/Cargar la batería”. Pueden ser los cables, los cuáles hay que verificar si están bien. Si no lo estuvieran la reparación sería “Cambiar los cables”. Podrían ser también los contactos de los contactos en la batería. Si estuvieran mal habría que “cambiar/arreglar los contactos”. Por último podría ser el motor de arranque, el cual habría que verificar si está funcionando. Si no, la solución es “cambiar/arreglar el motor de arranque

Atributos: BATDESC (Batería Descargada, SI ó NO) ELECBAT (Funciona el Electrolito de la batería, SI ó NO) VOLTBAT (Funciona al medir con el Voltímetro, SI ó NO) CABLESMAL (Los cables están mal, SI ó NO) CONTACTOMAL (Los contactos están mal, SI ó NO) ARRANQUEMAL (El motor de arranque está mal, SI ó NO) REPARACION (Reparación sugerida) Base de Conocimientos: SI ELECBAT='NO' ENTONCES BATDESC='SI' SI VOLTBAT='NO' ENTONCES BATDESC='SI' SI ELECBAT='SI' Y VOLTBAT='SI' ENTONCES BATDESC='SI' SI BATDESC='SI' ENTONCES REPARACION = 'CAMBIO DE BATERIA' SI CABLESMAL='SI' ENTONCES REPARACION = 'CAMBIO DE CABLES' SI CONTACTOMAL='SI' ENTONCES REPARACION = 'CAMBIO DE CONTACTOS' SI ARRANQUEMAL='SI' ENTONCES REPARACION = 'REPARA MOTOR DE ARRANQUE„ SI BATDESC='NO' Y CABLESMAL='NO' Y CONTACTOMAL='NO' Y ARRANQUEMAL='NO' ENTONCES REPARACION = 'NO HAY SUGERENCIA'

4.8 Motor de inferencia

El motor de inferenci es la parte del Sistema Experto que controla el proceso de razonamiento. Utiliza los datos que se le suministran (Hechos) así como la Base de Conocimientos. Recorre la base de conocimientos para alcanzar una solución siguiendo cierta estrategia. La estrategia de control puede ser el encadenamiento hacia adelante (forward chaining) ó el encadenamiento hacia atrás (backward chaininig) 4.8.1 Encadenamientos Una regla de la Base de Conocimientos SI P1 Y P2 ENTONCES Q Se puede representar gráficamente mediante un Árbol, Figura 10, en el que la raíz representa la Conclusión y sus hijos la(s) Condición(es)

Figura 10. Representación de una Regla

En la estrategia de control forward chaining se parte de las condiciones (datos) hacia las conclusiones (resultados o metas), es decir, se recorre el árbol de abajo hacia arriba, en cambio en la estratégia backward chaining se parte de las conclusiones (metas) hacia las condiciones, es decir, se recorre el árbol de arriba hacia abajo. 4.8.2 Algoritmo de Forward chaining Enfoque guiado por Datos. Se parte de los hechos disponibles en la base de datos (Memoria de trabajo). Todas las reglas se marcan “Sin Evaluar” Introducimos el Atributo Objetivo (el que queremos inferir su valor) Durante el funcionamiento del algoritmo, las reglas podrán estar: “sin evaluar”, “evaluadas” Algoritmo general: [iniciar] 0) Marcar todas las reglas como “sin evaluar”. Colocar en la memoria de trabajo todos los hechos [verificar final del algoritmo] 1) Si el Atributo Objetivo está en la Memoria de Trabajo, termina el Sistema Experto, de lo contrario ir al paso 2) [buscar regla a evaluar] 2) Se busca una regla “Sin Evaluar” en la que todos los Atributos que intervienen en la Condición estén en la Memoria de Trabajo. Si No Existe tal regla, termina el Sistema Experto, con la indicación de que no hay suficiente conocimiento para inferir todos los atributos (también puede solicitar los datos al Usuario, con lo cual continuaría el algoritmo). Si existe la regla, continuar en el paso 3) [evaluar regla] 3) Se Evalúa (y se marca como evaluada) la regla encontrada. Si se cumple la Condición se agrega la Conclusión a la memoria y se regresa al paso 1). De lo contrario se regresa al paso 2) Ejemplo: Regla 1: SI C=„SI‟ ENTONCES E=„NO‟ Regla 2: SI A=„NO‟ ENTONCES D=„SI‟ Regla 3: SI A=„SI‟ ENTONCES C=„SI‟

Regla 4: SI B=„SI‟ ENTONCES D=„SI‟ Supongamos que tenemos los Hechos: A=„SI‟ B=„SI‟ Aplicar el Algoritmo de Forward Chaining para obtener el valor del Atributo D (Atributo Objetivo) La inicialización del algoritmo se muestra en la Tabla 6.

Tabla 6. Paso Inicial. Forward Chaining

MEMORIA DE TRABAJO REGLAS

A=„SI‟ (hecho) B=„SI‟ (hecho)

Regla 1 (sin evaluar) Regla 2 (sin evaluar) Regla 3 (sin evaluar) Regla 4 (sin evaluar)

Primera Iteración Paso 1) Verificar si D (objetivo) está en la memoria -> NO Paso 2) Buscar regla que se pueda evaluar -La Regla 1 No se puede evaluar porque C (condición) no está en la memoria de trabajo -La Regla 2 Si se puede evaluar porque A está en la memoria de trabajo Paso 3) Se evalúa la Regla. En este caso NO se cumple la condición. Se regresa al paso 2) Después de esta iteración los resultados se muestran en la Tabla 7.

Tabla 7. Primera Iteración. Forward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho)

Regla 1 (sin evaluar) Regla 2 (evaluada) Regla 3 (sin evaluar) Regla 4 (sin evaluar)

Segunda Iteración Paso 2) Buscar regla que se pueda evaluar -La Regla 1 No se puede evaluar porque C (condición) no está en la memoria de trabajo -La Regla 3 Si se puede evaluar porque A está en la memoria de trabajo Paso 3) Se evalúa la Regla. En este caso SI se cumple la condición. Se agrega la Conclusión a la Memoria y se regresa al paso 1) Después de esta iteración, los resultados se muestran en la Tabla 8.:

Tabla 8. Segunda Iteración. Forward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) C=„SI‟ (regla 3)

Regla 1 (sin evaluar) Regla 2 (evaluada) Regla 3 (evaluada) Regla 4 (sin evaluar)

Tercera Itereación Paso 1) Verificar si D (objetivo) está en la memoria -> NO Paso 2) Buscar regla que se pueda evaluar -La Regla 1 Si se puede evaluar porque C está en la memoria de trabajo Paso 3) Se evalúa la Regla. En este caso SI se cumple la condición. Se agrega la Conclusión a la Memoria y se regresa al paso 1) Después de esta iteración los resultados se muestran en la Tabla 9.

Tabla 9. Tercera Iteración. Forward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) C=„SI‟ (regla 3) E=„NO‟ (regla 1)

Regla 1 (evaluada) Regla 2 (evaluada) Regla 3 (evaluada) Regla 4 (sin evaluar)

Cuarta Iteración Paso 1) Verificar si D (objetivo) está en la memoria -> NO Paso 2) Buscar regla que se pueda evaluar -La Regla 4 Si se puede evaluar porque B está en la memoria de trabajo Paso 3) Se evalúa la Regla. En este caso SI se cumple la condición. Se agrega la Conclusión a la Memoria y se regresa al paso 1) Después de esta iteración los resultados se muestran en la Tabla 10.

Tabla 10. Cuarta Iteración. Forward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) C=„SI‟ (regla 3) E=„NO‟ (regla 1) D=„SI‟ (regla 4)

Regla 1 (evaluada) Regla 2 (evaluada) Regla 3 (evaluada) Regla 4 (evaluada)

Quinta Iteración Paso 1) Verificar si D está en la memoria -> SI, por tanto termina la inferencia del Sistema Experto Estado Final, se muestra en la Tabla 11.

Tabla 11. Quinta y última Iteración. Forward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) C=„SI‟ (regla 3) E=„NO‟ (regla 1) D=„SI‟ (regla 4)

Regla 1 (evaluada) Regla 2 (evaluada) Regla 3 (evaluada) Regla 4 (evaluada)

4.8.3 Algoritmo de Backward chaining Enfoque guiado por Objetivo Se parte de los Hechos disponibles en la base de datos (Memoria de trabajo). Todas las reglas se marcan “Sin Evaluar” Introducimos el Atributo Objetivo (el que queremos inferir su valor) Se utiliza una Lista de Atributos que se están evaluando (“Atributos evaluándose” Se utiliza una Lista de Reglas que se están evaluando (“Reglas evaluándose”) Durante el algoritmo: -Los atributos en la memoria podrán tener valor ó podrán estar “evaluándose” -Las reglas podrán estar: “sin evaluar”, “evaluadas”, “evaluándose” Algoritmo general: [iniciar] 0) Colocar en la memoria de trabajo al Atributo Objetivo como “evaluándose”. Colocar en la lista de “Atributos evaluándose” al Objetivo. Marcar todas las reglas como “sin evaluar” [verificar final del algoritmo] 1) Si el Atributo Objetivo está en la Memoria de Trabajo con un valor, termina el Sistema Experto, de lo contrario ir al paso 2) [elegir atributo a evaluar] 2) Sacar de la Lista de “Atributos evalúandose” al último atributo agregado, sea Atrib e ir al paso 3) [buscar regla a evaluar] 3) Se busca una Regla “Sin Evaluar” que tenga a Atrib como conclusión. Si No Existe tal regla se solicita el valor al Usuario, asignándole al atributo el valor ingresado y regresar al paso 1). Si existe la regla, ir al paso 4) [verificar si la regla se puede evaluar] 4) Si todos los atributos de la Condición de esa Regla están en la memoria de Trabajo y tienen valor ir al paso 5) de lo contrario ir al paso 7) [evaluar regla] 5) Se evalúa (y se marca como evaluada) la regla.

Si se cumple la condición se agrega la Conclusión a la memoria (se le da valor al atributo de la conclusión) y se va al paso 6). De lo contrario volver a agregar a la lista de “Atributos evaluándose” a Atrib y regresar al paso 2) [verificar otras reglas pendientes, que se puedan evaluar] 6) Verificar si había alguna regla en la lista de “reglas evaluándose” que estaba pendiente porque sólo le faltaba el valor del atributo recién evaluado. Si existe, quitarla de la lista (para evaluarla) y sea Atrib el atributo de su conclusión el cual quitaremos de la lista de atributos evaluándose. Ir al paso 5). De lo contrario ir al paso 1) [colocar regla para ser evaluada, así como sus atributos] 7) Poner en la pila nuevamente a Atrib y a todos los atributos que están en la condición que no tengan valor y que no estén marcados como “evaluándose” en la memoria de trabajo. Marcar a estos como “evaluándose” y agregar la regla a la lista de reglas que se están evaluando. Marcar la regla como “evaluándose”. Ir al paso 2) Ejemplo: Regla 1: SI C=„SI‟ ENTONCES E=„NO‟ Regla 2: SI C=„SI‟ ENTONCES D=„SI‟ Regla 3: SI A=„NO‟ ENTONCES C=„SI‟ Regla 4: SI B=„SI‟ ENTONCES C=„SI‟ Supongamos que tenemos los Hechos: A=„SI‟ B=„SI‟ Aplicar el Algoritmo de Backward Chaining para obtener el valor del Atributo D (Atributo Objetivo) Paso 0 (Tabla 12)

Tabla 12. Paso Inicial. Backward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) D=evaluándose

Regla 1 (sin evaluar) Regla 2 (sin evaluar) Regla 3 (sin evaluar) Regla 4 (sin evaluar)

Lista de atributos evaluándose Lista de reglas evaluándose

D

Primera Iteración Paso 1) Verificar si D está en la memoria de trabajo con Valor -> NO Paso 2) Atrib <- D (último de la lista de atributos evaluándose) Paso 3) Buscar regla “sin evaluar” que tenga a D como conclusión -> en este caso la Regla 2. Paso 4) Verificar la Condición -> El atributo C no está en la memoria. Paso 7) Agregar D y C a la lista de atributos evaluándose. Agregar la Regla 2 a la lista de reglas evaluándose. Regresar al paso 2)

Después de esta iteración los resultados se muestran en la Tabla 13.

Tabla 13. Primera Iteración. Backward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) D=evaluándose C=evaluándose

Regla 1 (sin evaluar) Regla 2 (evaluándose) Regla 3 (sin evaluar) Regla 4 (sin evaluar)


D, C Regla 2

Segunda Iteración Paso 2) Atrib <- C (último de la lista de atributos evaluándose) Paso 3) Buscar regla “sin evaluar” que tenga a C como conclusión -> en este caso la Regla 3. Paso 4) Verificar la Condición -> El atributo A está en la memoria y tiene valor. Paso 5) Se evalúa y marca la regla. En este caso No se cumple la condición A=„NO‟. Se coloca nuevamente a C en la lista. Regresa al paso 2) Después de esta iteración los resultados se muestran en la Tabla 14.

Tabla 14. Segunda Iteración. Backward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) D=evaluándose C=evaluándose

Regla 1 (sin evaluar) Regla 2 (evaluándose) Regla 3 (evaluada) Regla 4 (sin evaluar)


D, C Regla 2

Tercera Iteración Paso 2) Atrib <- C (último de la lista de atributos evaluándose) Paso 3) Buscar regla “sin evaluar” que tenga a C como conclusión -> en este caso la Regla 4. Paso 4) Verificar la Condición -> El atributo B está en la memoria y tiene valor. Paso 5) Se evalúa y marca la regla 4. En este caso Sí se cumple la condición B=„SI‟. Se agrega la conclusión a la memoria (valor a C) Paso 6) La regla 2 se quita de la lista. Atrib <- D y D se quita de la lista. Paso 5) Se evalúa y marca la regla 2. En este caso Sí se cumple la condición C=„SI‟. Se agrega la conclusión a la memoria (valor a D) Paso 6) No hay reglas pendientes que dependan de D. Se regresa al paso 1) Cuarta Iteración

Paso 1) Verificar si D está en la memoria de trabajo con Valor -> SI, por tanto termina la inferencia del Sistema Experto Estado Final, se muestra en la Tabla 15:

Tabla 15. Cuarta y última Iteración. Backward Chaining


A=„SI‟ (hecho) B=„SI‟ (hecho) D=„SI‟ (regla 2) C=„SI‟ (regla 4)

Regla 1 (sin evaluar) Regla 2 (evaluada) Regla 3 (evaluada) Regla 4 (evaluada)


4.8.4 Comparación de las dos estrategias La Tabla 16, muestra algunas ventajas y desventajas, de manera comparativa entre las dos estrategias de control de razonamiento.

Tabla 16. Comparación entre las estrategias

FORWARD CHAINING BACKWARD CHAINING

Intenta obtener los valores de todos los atributos hasta encontrar el Objetivo, evaluando todas las reglas posibles Ventaja: Para aplicaciones en las que se requiera obtener el valor de todos los atributos. No hay un objetivo en concreto. La condición de terminación es que todos los atributos tengan valor. Desventaja: Cuando lo que se requiere es evaluar un Objetivo en particular, posiblemente se evalúen reglas y se obtengan valores de atributos que no eran necesarios

Sólo evalúa las reglas relacionadas con el Objetivo Ventaja: No se evalúan reglas innecesarias ni se determinan valores de atributos que no se requieran para obtener el valor del objetivo Desventaja: No se obtiene el valor de todos los atributos de la base de conocimiento, lo cual puede ser importante en algunas aplicaciones

La elección del mecanismo de inferencia depende del tipo de aplicación del Sistema Experto. 4.8.5 Resolución de Conflicto El conjunto de reglas en la Base de Conocimientos puede ser de dos tipos: 1.- Determinístico - en cada iteración sólo hay una regla que se puede ejecutar, es decir hay un "camino" único para la solución del problema.

2.- No-determinístico - en cada iteración puede haber varias reglas que pueden ejecutarse, es decir que hay varios "caminos" o soluciones posibles Los sistemas "reales" son generalmente no-determinísticos, por lo que tiene que haber una estrategia para seleccionar una regla cuando varias se apliquen, o estén en conflicto en cierto instante. A este mecanismo se le conoce como resolución de conflicto Existen varias formas de resolución de conflicto, pero en general casi todas combinan tres técnicas: 1. Reglas no-repetidas (refractoriness)- no seleccionar las reglas que se estén evaluando. Sirve para evitar ciclos (recursiones). 2. Reglas recientes (recency) - seleccionar las reglas que involucren atributos más recientes en la memoria de trabajo 3. Reglas específicas (specificity) - seleccionar reglas mas específicas, es decir, aquellas con más condiciones satisfechas Estas técnicas son genéricas y aunque no garantizan la mejor solución, proveen generalmente una solución adecuada.

CAPÍTULO V: PROGRAMACIÓN LÓGICA

5.1 Programación declarativa

En los paradigmas de programación declarativa los programas se construyen señalando hechos, reglas, restricciones, ecuaciones, transformaciones y otras propiedades derivadas del conjunto de valores que configuran la solución [6]. A partir de esta información el sistema debe de proporcionar un esquema que incluya el orden de evaluación que compute una solución. Aquí no existe la descripción de las diferentes etapas a seguir para alcanzar una solución, como en el paradigma imperativo. Estos paradigmas permiten el uso de variables para almacenar valores intermedios, pero no para actualizar estados de información.

5.2 Programación lógica

El paradigma lógico difiere de forma importante de otros paradigmas. No sólo en su sintaxis o semántica, sino que en él la lógica representa conocimiento, el cual es manipulado mediante inferencias. A diferencia de los demás paradigmas, trabajar en éste significa especificar qué hacer y no cómo hacerlo, por ello son llamados lenguajes declarativos [6]. El proceso general de la programación lógica es que a partir de un conjunto de reglas (axiomas) e inferencias podamos comprobar nuevas proposiciones que nos sean relevantes. Este proceso está basado en reglas de lógica de primer orden. El Prolog es el lenguaje más representativo en este paradigma, aunque existen otros ejemplos como el Structured Query Language (SQL), un lenguaje para operar bases de datos. En este paradigma los programas se consideran como una serie de aserciones lógicas. De esta forma, el conocimiento se representa mediante reglas, tratándose así de un paradigma declarativo. Una representación declarativa es aquella en la que el conocimiento está especificado; pero no está especificado cómo ese conocimiento debe ser usado. El lenguaje de programación más representativo de la programación lógica es el Prolog. Ejemplo en Prolog:

hijo(A,B) :- padre(B,A). abuelo(A,B) :- padre(A,C), padre(C,B). hermano(A,B) :- padre(C,A), padre(C,B), A <> B. padre(juan, maria). padre(pablo, juan). padre(pablo, marcela). padre(carlos, debora). Goal: hermano(juan,marcela)

yes Goal: padre(pablo,X)

X=juan X=marcela 2 Solutions

5.3 Breve historia del Prolog

Ya desde los años 50 existía la inquietud de realizar demostración automática de teoremas. Primeros trabajos de inteligencia artificial [6]. En los años 70 surge el primer lenguaje de programación que contempla, como parte del intérprete, los mecanismos de inferencia necesarios para la demostración automática. Basado en el formalismo matemático de la Lógica de Primer Orden. Dio inicio al campo de investigación en las matemáticas y la computación denominado: Programación Lógica. En el año 1970 se desarrolló el PROLOG en la Universidad de Marsella, Francia, en el seno de un grupo de investigación en el campo de la Inteligencia Artificial. Es un lenguaje de programación diseñado para representar y utilizar el conocimiento que se tiene sobre un determinado dominio. El dominio es un conjunto de objetos y el conocimiento se representa por un conjunto de relaciones que describen las propiedades de los objetos y sus interrelaciones. Un conjunto de reglas que describa éstas propiedades y éstas relaciones es un programa PROLOG. Así entonces, PROLOG es un lenguaje de programación que es usado para resolver problemas que envuelven objetos y las relaciones entre ellos, y este conocimiento se describe utilizando reglas. Se llega a las soluciones realizando inferencias lógicas a partir de una colección de hechos y reglas, de los cuales se deducen conclusiones. La lógica de primer orden, (lógica de predicados ó cálculo de predicados), es un sistema formal diseñado para estudiar la inferencia en los lenguajes de primer orden (utilizan cuantificadores, variables de individuo, predicados, funciones, etc.). En el Prolog se utiliza una variación simplificada de la sintaxis de la lógica de predicados, la cual es bastante similar a la del idioma natural. El PROLOG incluye un motor de inferencias que acciona lógicamente sobre la información, además este contiene un emparejador(matcher) que recupera la información guardada (o conocida) emparejando las respuestas a las preguntas. Un rasgo importante de PROLOG es que, además de encontrar las respuestas lógicas a las preguntas que se le haga, puede encontrar todos las soluciones posibles en lugar de sólo una.

5.4 Elementos principales del Prolog

Hechos Variables

Reglas Consultas Ámbito de las variables Mecanismo de control de razonamiento

5.4.1 Hechos Expresan relaciones entre objetos. Supongamos que queremos expresar el hecho de que "un auto tiene ruedas". Este hecho, consta de dos objetos, "auto" y "ruedas", y de una relación llamada "tiene". Una forma de representarlo en PROLOG es: tiene(auto,ruedas). Otro podría ser ("un auto tiene motor") tiene(auto,motor). Los nombres de objetos y relaciones deben comenzar con una letra minúscula. Primero se escribe la relación, y luego los objetos separados por comas y encerrados entre paréntesis. Al final de un hecho debe ir un punto (el carácter "."). El orden de los objetos dentro de la relación es arbitrario, pero debemos ser coherentes a lo largo de la base de hechos. En el PROLOG, una relación entre los objetos se llama un predicado. En el idioma natural, una relación se expresa por una frase. En la lógica de predicados, que el PROLOG usa, una relación se resume en “un hecho”. Otros ejemplos,se muestran en la Tabla 17.

Tabla 17. Ejemplos de frases y hechos

FRASES HECHOS EN PROLOG

A Marco le gusta Rosa gusta(marco, rosa).

A Rosa le gusta Juan gusta(rosa, juan).

A Marco le gustan los perros gusta(marco, perros).

Los hechos también pueden expresar propiedades ó comportamientos de objetos Ejemplos: "Hulk es verde“, "Rosario es una Chica”, “El precio sube”, “Sí comprar” “No comprar” verde(hulk). chica(rosario). precio(sube). comprar(si). comprar(no). Del ejemplo inicial, son hechos:

padre(juan, maria). padre(pablo, juan). padre(pablo, marcela). padre(carlos, debora).

5.4.2 Variables Se utilizan para que el PROLOG determine (infiera) resultados. Una variable puede estar instanciada (con valor) o no instanciada (sin valor). Está instanciada cuando existe un objeto determinado representado por la variable (ya tiene valor). De este modo, cuando preguntamos:

tiene(auto,X) (significa: qué tiene un auto?) Al preguntar, X no está instanciada. El Prolog aplica su razonamiento para intentar instanciarla. Busca en los hechos (y reglas) cosas que tiene un auto y respondería:

X = ruedas X = motor

instanciando así la variable X con el objeto ruedas y con el objeto motor (en este caso, dos soluciones diferentes para la misma pregunta). Los nombres de variables comienzan siempre por una letra mayúscula. 5.4.3 Reglas Las reglas se utilizan en PROLOG para expresar que una relación depende de una o más relaciones. Son la representación de las implicaciones lógicas del tipo p -> q (p implica q) (aunque en Prolog se expresa al revés). Una regla consiste en una cabeza (q-conclusión) y un cuerpo (p-antecedente), unidos por “:-” La cabeza está formada por una única relación. El cuerpo puede ser una o más relaciones (conjunción de relaciones), separadas por una coma (","), que actúa como el "y" lógico. Las reglas finalizan con un punto ("."). La cabeza en una regla PROLOG corresponde al consecuente de una implicación lógica, y el cuerpo al antecedente. Forma general de una regla: consecuente :- antecedente . Las reglas permiten se que infieran hechos de otros hechos ó relaciones. Ejemplos: A Maria le gusta todo lo que le gusta a Juan. A Luisa le gusta todo lo que es verde. gusta(maria,X) :- gusta(juan,X). gusta(luisa,X) :- verde(X). Entonces, con las reglas anteriores y los siguientes hechos: verde(hulk). gusta(juan,gatos). Se puede inferir que a Luisa el gusta Hulk y que a Maria le gustan los gatos. 5.4.4 Consultas

Una vez descrito el conocimiento, utilizando reglas y hechos, se pueden realizar consultas al Prolog, quien utilizará su mecanismo de inferencia para obtener la (o las) respuestas. Supongamos el siguiente conjunto de reglas y hechos:

gusta(maria,X) :- gusta(juan,X). gusta(luisa,X) :- verde(X). gusta(juan,gatos). gusta(juan,luisa). verde(hulk).

En la tabla 18 se muestran algunas preguntas, consultas y las respuestas que brinda el Prolog para el ejemplo anterior:

Tabla 18. Preguntas, Consultas y Respuestas

PREGUNTA CONSULTA PROLOG RESPUESTA DEL PROLOG

¿Qué le gusta a María? gusta(maria,X) X=gatos X=luisa

¿A María le gusta Hulk? gusta(maria,hulk) No

¿A quién le gustan los gatos?

gusta(X,gatos) X=maria X=juan

5.4.5 Ámbito de las variables Cuando en una regla aparece una variable, el ámbito de esa variable es Únicamente esa regla. Supongamos las siguientes reglas:

(1) hermana(X,Y) :- mujer(X), padres(X,M,P), padres(Y,M,P). (2) puederobar(X,P) :- ladron(X), legusta(X,P), valioso(P).

Aunque en ambas reglas aparece la variable X (también la variable P), no tiene relación una con otra. La instanciación de X en (1) no implica la instanciación de X en (2) . Son variables diferentes. Significa que una variable tiene alcance (su ámbito) sólo en la regla. Una vez instanciada la variable X, en una regla, todas las X que aparecen en esa regla hacen referencia, automáticamente, al mismo valor. 6.4.6 Mecanismo de control El mecanismo empleado por PROLOG para resolver las consultas, es el de razonamiento hacia atrás (backward chainning) complementado con la búsqueda de primero en profundidad (depthfirst) y la reevaluación (backtracking). Razonamiento hacia atrás: Significa que el razonamiento parte de la evaluación de las reglas relacionadas con el Objetivo a probar (conclusión). Si existe más de una regla (caso no determinista) las intenta evaluar en el orden en que aparecen en el programa.

Reevaluación: Si en un momento dado una variable se instancia con determinado valor con el fin de alcanzar una solución, y se llega a un camino no satisfactorio, el mecanismo de control retrocede al punto en el cual se instanció la variable, la “des-instancia” y si es posible, busca otra instanciación que supondrá un nuevo camino de búsqueda. Durante el proceso de inferencia el Prolog va obteniendo una serie de caminos de búsqueda (de un árbol de búsqueda) los cuales se van explorando siguiendo el criterio de búsqueda de primero en profundidad Ejemplo:

(1) puedecasarsecon(X,Y) :- quiere(X,Y), hombre(X), mujer(Y). (2) puedecasarsecon(X,Y) :- quiere(X,Y), mujer(X), hombre(Y). (3) mujer(maria). (4) mujer(susana). (5) hombre(enrique). (6) quiere(maria,enrique). (7) quiere(maria,susana).

Supongamos que preguntamos:

Goal: puedecasarsecon(maria,X) El Prolog recorre la base de reglas (en orden) buscando una regla cuya conclusión coincida con la pregunta realizada. En este caso la pregunta:

puedecasarsecon(maria,X) conicide con la conclusión de la regla (1)

(1) puedecasarsecon(X,Y) :- quiere(X,Y), hombre(X), mujer(Y). instanciando la X con maria

puedecasarsecon(maria,Y) :- quiere(maria,Y), hombre(maria), mujer(Y). Para lo cual debe ahora, verificar si el antecedente se cumple. El antecedente depende de tres relaciones (unidas por la operación logica “y”):

quiere(maria,Y), hombre(maria), mujer(Y). Se convierte, entonces, quiere(maria,Y) en el nuevo Objetivo ó pregunta a resolver. El Prolog recorre la base de reglas (en orden) buscando una regla cuya conclusión coincida con el nuevo objetivo ó pregunta. En este caso la pregunta:

quiere(maria,Y) coincide con hecho de la regla (6)

(6) quiere(maria,enrique). instanciando la Y de la pregunta con enrique Con esto queda resuelto el objetivo y regresa a la regla (1) con la Y instanciada:

quiere(maria,enrique), hombre(maria), mujer(enrique). Falta por verificar que se cumplan las dos últimas condiciones Se convierte, entonces, hombre(maria) en el nuevo Objetivo ó pregunta a resolver. El Prolog recorre la base de reglas (en orden) buscando una regla cuya conclusión coincida con el nuevo objetivo ó pregunta. En este caso para la pregunta:

hombre(maria)

No existe ninguna regla que satisfaga al objetivo. Por tanto debe regresar a la regla 1 para intentar buscar otra solución para

quiere(maria,Y). Para lo cual des-instancia la Y (que tenía el valor de enrique) Busca otra alternativa para quiere(maria,Y) y encuentra quiere(maria,susana), instanciandose nuevamente la Y, ahora con susana Quedando la regla (1)

quiere(maria,susana), hombre(maria), mujer(susana) Nuevamente se convierte, hombre(maria) en el nuevo Objetivo ó pregunta a resolver. Vuelve a fallar el intento de resolver la pregunta

hombre(maria) Ya que no existe ninguna regla que satisfaga al objetivo. Por tanto nuevamente debe regresar a la regla 1 para intentar buscar otra solución para

quiere(maria,Y). Para lo cual des-instancia la Y (que tenía el valor de susana) Busca otra alternativa para quiere(maria,Y) y ya no hay mas, por tanto falla la primera condición de la regla (1) y porta tanto falla toda la regla. Al fallar la regla (1) el Prolog busca otra alternativa para el objetivo por el cual se estaba utilizando esa regla:

puedecasarsecon(maria,X) El Prolog continúa buscando en la base de reglas (en orden) otra regla cuya conclusión coincida con la pregunta realizada. En este caso la pregunta:

puedecasarsecon(maria,X) coincide con la conclusión de la regla (2)

(2) puedecasarsecon(X,Y) :- quiere(X,Y), mujer(X), hombre(Y). instanciando la X con maria

puedecasarsecon(maria,Y) :- quiere(maria,Y), mujer(maria), hombre(Y). Para lo cual debe ahora, verificar si el antecedente se cumple.

quiere(maria,Y), mujer(maria), hombre(Y). Se convierte, entonces, quiere(maria,Y) en el nuevo Objetivo ó pregunta a resolver. El Prolog recorre la base de reglas (en orden) buscando una regla cuya conclusión coincida con el nuevo objetivo ó pregunta. En este caso la pregunta:

quiere(maria,Y) conicide con hecho de la regla (6)

(6) quiere(maria,enrique). instanciando la Y de la pregunta con enrique Con esto queda resuelto el objetivo y regresa a la regla (2) con la Y instanciada:

quiere(maria,enrique), mujer(maria), hombre(enrique). Falta por verificar que se cumplan las dos últimas condiciones Se convierte, entonces, mujer(maria) en el nuevo Objetivo ó pregunta a resolver. El Prolog recorre la base de reglas y encuentra el hecho

(3) mujer(maria). Que coincide con el objetivo.

Regresa a la regla (2) en la que ya tiene dos de las condiciones satisfechas. quiere(maria,enrique), mujer(maria), hombre(enrique).

Falta por verificar que se cumpla la última condición Se convierte, entonces, hombre(enrique) en el nuevo Objetivo ó pregunta a resolver. El Prolog recorre la base de reglas y encuentra el hecho

(5) hombre(enrique). Que coincide con el objetivo. Regresa a la regla (2) en la que ya se han cumplido todas las condiciones

quiere(maria,enrique), mujer(maria), hombre(enrique). Como ya se han cumplido todas las condiciones de la regla (el antecedente) entonces se puede afirmar la conclusión de la regla:

(2) puedecasarsecon(maria,enrique) :- quiere(maria,enrique), mujer(maria), hombre(enrique). Con lo cual, la pregunta inicial:

puedecasarsecon(maria,X) Queda resuelta, con la respuesta:

X = enrique

5.5 Aplicación del Prolog a los Sistemas Expertos

A continuación veremos cómo crear un sistema experto utilizando el lenguaje Prolog. Partiremos del siguiente conocimiento para el otorgamiento de un empleo a un aspirante. Si contesta firmemente entonces tiene facilidad de palabra. Si parece honesto entonces contesta firmemente. Si declara habilidades no comprobables entonces no parece honesto. De lo contrario parece honesto. Si está dispuesto a conversar con un ejecutivo entonces es capaz de conversar con un ejecutivo. Si es capaz de conversar con un ejecutivo y además tiene facilidad de palabra entonces es amable. Si es amable entonces tiene habilidades interpersonales. Si tiene habilidades interpersonales entonces se le da el empleo Podemos definir predicados de la forma:

atributo(valor) Ejemplo:

empleo(si) empleo(no) facpal(si) …. De esta manera las reglas escritas en Prolog, quedarían:

facpal(si) :- confir(si). facpal(no) :- confir(no). confir(si) :- honesto(si). confir(no) :- honesto(no).

honesto(no) :- habnocomp(si). honesto(si) :- habnocomp(no). capconv(si) :- dispconv(si). capconv(no) :- dispconv(no). amable(si) :- capconv(si), facpal(si).

amable(no) :- capconv(no). amable(no) :- facpal(no). habinter(si) :- amable(si).

habinter(no) :- amable(no). empleo(si) :- habinter(si). empleo(no) :- habinter(no).

En este caso para ejecutar el programa (sistema experto) debemos darle los hechos que conocemos con respecto a algunos atributos . Por ejemplo, si conocemos que el aspirante no declara habilidades no comprobables y está dispuesto a conversar con un ejecutivo ¿Se le da el empleo?, deberíamos agregar a las reglas, los hechos:

habnocomp(no). dispconv(si).

Finalmente la consulta al Prolog sería: empleo(X)

Programa completo en Prolog: predicates

nondeterm facpal(symbol).

nondeterm contfir(symbol).

nondeterm honesto(symbol).

nondeterm habnocomp(symbol).

nondeterm capconv(symbol).

nondeterm amable(symbol).

nondeterm dispconv(symbol).

nondeterm habinter(symbol).

nondeterm empleo(symbol).

clauses

facpal(si) :- contfir(si).

facpal(no) :- contfir(no).

contfir(si) :- honesto(si).

contfir(no) :- honesto(no).

honesto(no) :- habnocomp(si).

honesto(si) :- habnocomp(no).

capconv(si) :- dispconv(si).

capconv(no) :- dispconv(no).

amable(si) :- capconv(si), facpal(si).

amable(no) :- capconv(no).

amable(no) :- facpal(no).

habinter(si) :- amable(si).

habinter(no) :- amable(no).

empleo(si) :- habinter(si).

empleo(no) :- habinter(no).

habnocomp(no).

dispconv(si).

goal

empleo(X),

write("El resultado de empelo es: ", X).

La solución anterior presenta los siguientes problemas:

a) Se quiere un predicado diferente por cada atributo. b) Los datos iniciales están suministrados como hechos. Lo usual en un sistema experto es que el sistema le pregunte al usuario el valor de aquellos atributos que no es posible inferir a través de alguna regla c) El objetivo siempre es el mismo. En un sistema experto, si bien hay un objetivo principal, es posible aplicarlo para obtener otros resultados. Por ejemplo, en lugar de querer conocer si se le da el empleo ó no, podría ser conocer si es amable ó no (que es otro atributo de la base de conocimientos) Mejoras a la solución Para el primer problema:

a)Se quiere un predicado diferente por cada atributo) La solución es definir um solo predicado que generaliza la relación “atributo-valor” :

av(atributo, valor) Por ejemplo: av(empleo,si) av(empleo,no) av(facpal,si) Para el segundo problema: b) Los datos iniciales están suministrados como hechos. La solución es agregar otra regla para el predicado av, que permita ingresar el valor del atributo.

av(X,Y) :- write("Ingrese el valor de "), write(X),

readln(Z), Y=Z.

Esta solución tiene otro problema y es que los valores ingresados por el usuario no “perduran”, debido al mecanismo de desinstanciación del prolog y del alcance local de los valores de las variables. Se requiere, entonces, que el valor ingresado se almacene en la memoria de trabajo del Prolog. Para ello se define un nuevo predicado que servirá para almacenar como “hechos” los valores ingresados por el usuario. Este predicado también sirve para definir hechos que se conozacan a priori. El nuevo predicado debe tener un nombre diferente a av, ya que se utilizará sólo para almacenar “hechos”

avh(atributo, valor) Finalmente las reglas para obtener el valor de un atributo, ya sea de la base de hechos ó solicitándoselo al usuario serían dos:

av(X,Y) :- avh(X,Y),!. av(X,Y) :- write("Ingrese el valor de "),

write(X), readln(Z), Y=Z, asserta(avh(X,Z)). La primera regla recupera el valor Y del atributo X si éste atributo ya está en la base de hechos (memoria de trabajo). El último predicado se ejecuta cuando se necesita el valor del atributo X y no está en la base de hechos. En ese caso se le solicita al usuario y se registra el valor en la base de hechos (asserta)

Para el tercer problema: c)Permitir evaluar cualquier objetivo

La solución es simple ya que con el predicado av(X,Y) podemos consultar al Prolog el valor de cualquier atributo, instanciándolo en el valor de X. Incluso se puede solicitar al usuario cuál es el valor del atributo a evaluar:

goal write("Atributo a evaluar?: "), readln(A), av(A,X), write("El resultado de",A," es:",X,"\n" ).

Por último, las reglas que permiten obtener los valores de los atributos deben ser modificadas en el antecedente para que el Prolog busque el valor de los atributos en lugar de verificar explícitamente por un hecho concreto: Ej. Las reglas:

amable(si) :- capconv(si), facpal(si). amable(no) :- capconv(no). amable(no) :- facpal(no).

Quedarían de la siguiente manera: av(amable,si) :- av(capconv,X), X=si, av(facpal,Y), Y=si,!. av(amable,no) :- av(capconv,X), X=no,!. av(amable,no) :- av(facpal,X), X=no,!.

El nuevo programa, completo, en Prolog sería: database

avh(symbol,symbol)

predicates

nondeterm av(symbol,symbol)

nondeterm limpiar

clauses

av(facpal,si) :- av(contfir,X),X=si,!.

av(facpal,no) :- av(contfir,X),X=no,!.

av(contfir,si) :- av(honesto,X),X=si,!.

av(contfir,no) :- av(honesto,X),X=no,!.

av(honesto,no) :- av(habnocomp,X),X=si,!.

av(honesto,si) :- av(habnocomp,X),X=no,!.

av(capconv,si) :- av(dispconv,X),X=si,!.

av(capconv,no) :- av(dispconv,X),X=no,!.

av(amable,si) :- av(capconv,X),X=si,

av(facpal,Y),Y=si,!.

av(amable,no) :- av(capconv,X),X=no,!.

av(amable,no) :- av(facpal,X),X=no,!.

av(habinter,si) :- av(amable,X),X=si,!.

av(habinter,no) :- av(amable,X),X=no,!.

av(empleo,si) :- av(habinter,X),X=si,!.

av(empleo,no) :- av(habinter,X),X=no,!.

av(X,Y) :- avh(X,Y),!.

av(X,Y) :- write(X), write( " (si/no): "),

readln(Z), Y=Z,

asserta(avh(X,Z)).

limpiar :- retract(avh(_,_)),fail.

goal

write("Atributo a evaluar? (empleo): "),

readln(A),

av(A,X),

write("El resultado de ", A, " es: ", X, "\n" ),

limpiar.

El predicado limpiar, permite, una vez concluida la ejecución del sistema experto, eliminar de la base de hechos del prolog los hechos avh(X,Y), correspondientes a los valores ingresados por el usuario.

CAPÍTULO VI: RECONOCIMIENTO DE PATRONES

6.1 Introducción

El reconocimiento de patrones es una área de la tecnología conocida como Aprendizaje de Máquinas (Machine Learning) o Aprendizaje Automático. Mas del 50% de las aplicaciones de la industria de la inteligencia artificial es de Reconocimiento de Patrones [7]. Consiste en Clasificar un patrón ó objeto de prueba en una determinada Clase ó categoria. Se determina la clase del objeto de prueba utilizando la información correspondiente a un conjunto conocido de objetos (conjunto de entrenamiento) El objetivo es clasificar patrones en base a un conocimiento a priori o información estadística extraída de los patrones. Los patrones a clasificar suelen ser grupos de medidas u observaciones, definiendo puntos en un espacio multidimensional apropiado Un sistema de reconocimiento de patrones completo consiste en un sensor que recoge las observaciones a clasificar, un sistema de extracción de características que transforma la información observada en valores numéricos o simbólicos, y un sistema de clasificación o descripción que, basado en las características extraídas, clasifica la medición. La Arquitectura de una Sistema de Reconocimiento de Patrones [3] se puede observar en la Figura 11.

Figura 11. Arquitectura de un Sistema de Reconocimiento de Patrones

6.2 Algunas aplicaciones

Reconocimiento de huellas digitales Reconocimiento de rostros En general, reconocimiento de objetos (forma, tamaño, color)

Reconocimiento de caracteres (OCR) (Optical Character Recognition) Reconocimiento de patrones acústicos y fonéticos de la voz Reconocimiento de patrones en señales de electrocardiogramas Clasificación de señales de radar Reconocimiento de frases (conjunto de palabras) Diagnósticos médicos Evaluación de materiales Análisis de información econômica Clasificación de documentos Reconocimiento de virus informáticos

En general cualquier problema de CLASIFICACIÓN

Enfoques: Sintáctico Estructural: Utilizan estructuras de datos simbólicas para representar los patrones de estudio (cadenas, grafos, gramáticas, autómatas) Estadístico: Utiliza patrones abstractos, determinados por sus características. Redes Neuronales Ejemplos: a) C1 = { 2,4,6,8 } C2 = { 1,3,5,7 } 3 ? Se determina a cuál conjunto pertenece el 3 b) C1 = números pares C2 = números impares 8 ? Se utiliza la propiedad X mod 2 para determinar la pertenencia c) C1 = 1 (1|0)* 0 C2 = 0 (0|1)* 1 C3 = …. 11011010 ? Se utiliza la regularidad de la expresión regular d) Diagnóstico médico: Sobre la base de informaciones almacendas en Historias Clínicas se tiene una sucesión de pacientes: P1, P2, P3,…,Pm1 que padecen la enfermedad E1 Pm1+1, Pm1+2, …, Pm2 que padecen la enfermedad E2 y asi sucesivamente ¿ Qué enfermedad posee el paciente Px ?

6.3 Conceptos básicos

6.3.1 Objetos admisibles, clases, rasgos Consideremos un universo de objetos admisibles M K1, K2 ,…, Kr subconjuntos propios, donde cada Ki es un subconjunto de M. Los conjuntos Ki le llamaremos clases (en total r clases) R = { X1, X2, …, XN } Conjunto de rasgos ó características que describen a los objetos Cada rasgo posee un conjunto de valores admisibles, incluyendo ausencia de información Ejemplo: R = { color, área, forma } color = {rojo, verde, azul } área = número real forma = { convexa, no convexa }

6.3.2 Descripción estándar de un objeto Una descripción estándar de un objeto O es un N-uplo (donde N es la cantidad de rasgos):

I(O) = ( X1(O), X2(O), … XN(O) ) Representa el valor que posee el objeto O en cada uno de sus rasgos Ejemplo:

I(O) = ( verde, 23.5, convexo ) 6.3.3 Función de comparación de rasgos Permite comparar individualmente los rasgos de dos objetos. Existe una función de comparación por cada rasgo (N rasgos -> N funciones): Ci ( Xi(Op), Xi(Oq) ) ϵ { 0,1 } Estas N funciones sirven para comparar individualmente los rasgos de los objetos, pero no para decidir si los objetos son semejantes. 6.3.4 Función de semejanza Permite comparar dos objetos en base a los valores de sus rasgos. S ( I(Op), I(Oq) ) ϵ { 0,1 } Las funciones de comparación de rasgos dependen del dominio de los valores de los rasgos. Algunos ejemplos de funciones de comparación de rasgos son: Por igualdad: Cuando los dos rasgos son iguales Por intervalo: Cuando los dos rasgos se encuentran en un mismo intervalo Por diferencia: Cuando el valor absoluto de la diferencia de los dos rasgos es menor que un ε (márgen de error) Por conjunto: Cuando los dos rasgos pertenecen al mismo conjunto Por relación: Cuando la división de la diferencia de los rasgos entre la diferencia entre los valores máximos y mínimos es menor que un ε (margen de error) 6.3.5 R-uplo de Pertenencia de O Para un objeto O, se define P(O) como:

P(O) = ( P1(O), P2(O),…,Pr(O) ) P(O) es un vector de r componentes que indica la pertenencia ó no del Objeto O a cada una de las r clases (K1, K2 ,…, Kr ) Cada valor Pi(O) es 1 ó 0 en dependencia de si O pertenece ó no a la clase Ki 6.3.6 Información Estándar de Clases Es la información que recoge la descripción de todos los objetos conocidos por cada clase.

I(Ki)= ( I(Oi1), P(Oi1), I(Oi2), P(Oi2)…, I(Oiz), P(Oiz) )

6.3.7 Matriz de aprendizaje (de control ó muestra) Es la información estándar de todas las clases (conjunto de todos los objetos conocidos con sus rasgos y la clase a la que pertenece) I0 = ( I(K1), I(K2), …, I(Kr) ) Ejemplo: Universo de objetos admisibles: Conjunto de figuras geométricas planas. La Figura 12, muestra algunos ejemplos de objetos:

Figura 12. Ejemplos de objetos agrupados en 3 clases

Clases

C1 (blancos y convexos) C2 (blancos y no convexos) C3 (negros y cualquier forma)

Rasgos Color (Blanco ó Negro) Forma (Convexo ó No Convexo)

La descripción estándar de los objetos sería:

O1: ( negro, convexo ) O2: ( negro, convexo ) O3: ( blanco, no convexo ) O4: ( blanco, no convexo ) O5: ( blanco, convexo ) O6: ( blanco, convexo ) O7: ( negro, convexo ) O8: ( negro, no convexo ) O9: ( negro, convexo ) O10: ( blanco, no convexo )

La matriz de aprendizaje (de control ó muestra) sería:

O1: ( negro, convexo, C3 ) O2: ( negro, convexo, C3 ) O3: ( blanco, no convexo, C2 ) O4: ( blanco, no convexo, C2 ) O5: ( blanco, convexo, C1 ) O6: ( blanco, convexo, C1 ) O7: ( negro, convexo, C3 ) O8: ( negro, no convexo, C3 ) O9: ( negro, convexo, C3 ) O10: ( blanco, no convexo, C2 )

6.4 Problemas que abarca el reconocimiento de patrones

6.4.1 Clasificación supervisada Dado una matriz de aprendizaje I0 (ó control) y los rasgos I(O) de un objeto del cual no conocemos su clase, encontrar un Algoritmo que permita clasificarlo

A ( I0, I(O) ) = ( P1(O), P2(O),…,Pr(O) ) Dado los objetos de la Figura 12. ¿A qué clase pertenece el objeto de la Figura 13?

Figura 13. Objeto de clase desconocida

Algunos algoritmos de clasificación Supervisada

NN (Nearest Neighbor) KNN (K-Nearest Neighbor) Medios o centros KORA-3 Algunos modelos de redes neuronales (Ej. Superficies de separación -Perceptron) Análisis Discriminante

6.4.2 Selección de rasgos Consiste en encontrar los rasgos que permitan describir los objetos de manera tal que podamos diferenciar los objetos de cada clase Es importante una buena selección de rasgos para: a) Mejorar la clasificación (más rápido, menos información) b) Encontrar mejores soluciones. Mayor precisión en los resultados Algunos algoritmos para la selección de rasgos

Basados en Testores Típicos Algoritmo BT FS-Testor Zhuravliov Análisis Discriminante

6.4.3 Clasificación no supervisada (agrupamiento ó clustering). En este tipo de problemas se tienen los objetos de la matriz de aprendizaje, pero sin clasificar. No conocemos las clases y el problema consiste entonces en agruparlos por rasgos “comunes”. De esta manera se determinan las clases en que se podrían agrupar los objetos Dados los objetos de la Figura 14, ¿En qué clases se podrían agrupar?

Figura 14. Objetos sin agrupar

Algunos algoritmos de clasificación no supervisada (clustering)

K-Medias CLASS* Vector Quantization Algunos modelos de redes neuronales (Mapas autoorganizativos de Kohonen)

6.5 Algoritmo NN (Nearest Neighbour). Clasificación Supervisada

Fase de Aprendizaje [7]: Se determina, en primer lugar, en cuantas clases diferentes vamos a realizar la clasificación. Se determinan los rasgos que caracterizan a los objetos Se busca una muestra de objetos para cada clase y se le calculan sus rasgos, para formar la matriz de aprendizaje Fase de Clasificación: Se calculan los rasgos del objeto a clasificar y se calcula la "distancia" a cada uno de los objetos de la muestra La clasificación del objeto corresponde a la clase a la que pertenece aquel objeto de la muestra cuya distancia sea la mas cercana al objeto a clasificar Ejemplo: Supongamos que los objetos a clasificar son figuras geométricas y supongamos también que se agrupan en tres clases A, B y C que representan objetos redondos, semi-alargados y alargados respectivamente. Tendremos un solo rasgo ó característica, calculado en base a dos propiedades geométricas del objeto: división entre el diámetro mayor y menor del objeto Supongamos que tenemos el conjunto de objetos de la Figura 15, de los cuales conocemos sus rasgos y la clase a la que pertenece cada uno.

Figura 15. Conjuntos de objetos y sus clases

La matriz de aprendizaje se muestra en la Tabla 19. (Las clases A, B, y C estarían codificadas como 1, 2 y 3 respectivamente)

Tabla 19. Matriz de Aprendizaje

Objeto Rasgo Clase

1 1.250 1

2 1.288 1

3 1.001 1

4 1.197 1

5 1.737 2

6 1.786 2

7 2.023 2

8 1.985 2

9 4.370 3

10 5.414 3

11 4.728 3

12 3.962 3 Clasificación: Supongamos que queremos clasificar un nuevo objeto cuyo rasgo es: 1.6 Habría que calcular la “distancia” entre ese objeto y todos los de la matriz de aprendizaje para determinar cuál es el más cercano. En este caso como los objetos están definidos por un solo rasgo la distancia podría ser el valor absoluto de la resta de los rasgos distancia( O1, O2 ) = | X1(O1) – X1(O2) |

Tabla 20. Distancia del objeto desconocido a la muestra

Objeto Rasgo Clase |1.6 - Rasgo|

1 1.250 1 0.350

2 1.288 1 0.312

3 1.001 1 0.599

4 1.197 1 0.403

5 1.737 2 0.137

6 1.786 2 0.186

7 2.023 2 0.423

8 1.985 2 0.385

9 4.370 3 2.770

10 5.414 3 3.814

11 4.728 3 3.128

12 3.962 3 2.362

Como se observa en la Tabla 20, la menor distancia es 0.186, correspondiente al objeto número 6. Por tanto el objeto que estamos clasificando, cuyo rasgo es 1.6, pertenece a la clase 2 (clase del objeto 6, que es el más cercano [Nearest Neighbour] ) El proceso de clasificación es lento, ya que se requiere calcular la distancia entre el objeto y todos los objetos de la matriz de aprendizaje. Se requiere trabajar en un espacio métrico (que exista la función de distancia y que ésta cumpla ciertas propiedades). Se pueden presentar problemas como el que se observa en la Figura 16:

Figura 16. Problema del algoritmo NN

¿A qué clase pertenece el objeto amarillo, si aplicamos el algoritmo NN?

6.6 Algoritmo K-NN (K-Nearest Neighbour). Clasificación Supervisada

Es una generalización del algoritmo NN [7]. Consiste en determinar los K vecinos más cercanos y de ellos determinar la clase que mas se repite, y ésta sería la clase a la que

pertenece el objeto que estamos clasificando. El algoritmo NN es un caso particular del algoritmo KNN con K = 1.

6.7 Algunas funciones de distancia

Para el caso de K rasgos podemos utilizar la distancia Euclidiana u otra medida de distancia basada en la familia de distancias Ls ó Minkowski

Casos particulares: s = 1 (distancia Manhattan) s = 2 (distancia Euclidiana)

6.8 Análisis Discriminante. Clasificación Supervisada

Es una técnica de clasificación de objetos en la que se presupone la existencia de dos o más clases [8]. Los objetivos del análisis discriminante son: 1. Describir las diferencias existentes entre esos clases en base a los valores que toman ciertos rasgos sobre objetos de cada una de las clases 2. Clasificar nuevos objetos en alguna de las clases preexistentes en función de los valores que toman ciertas variables para esos objetos A manera de ejemplo, para ilustrar los conceptos, trabajaremos con tres clases de objetos, definidos a priori, de acuerdo a la forma de las figuras:

Clase A: Figuras Redondas Clase B: Figuras Semi-Redondas Clase C: Figuras Alargadas

Nuestro primer objetivo, en este caso, es tratar de determinar qué variables caracterizan las diferencias existentes entre estos tres grupos. El punto de partida de nuestro análisis es el conjunto de rasgos seleccionados para identificar a cada uno de los objetos. Trabajaremos con tres rasgos:

Diámetro Mayor del Objeto Diámetro Menor del Objeto División entre el Diam.Mayor y el Diam.Menor

6.8.1 Funciones discriminantes Técnicamente, podemos decir que el análisis discriminante tratará de encontrar funciones de estas tres variables ó rasgos cuyos valores separen o discriminen lo más posible a las tres clases existentes: A, B y C. Estas funciones, denominadas funciones o ejes discriminantes, serán combinaciones lineales de las variables originales de la forma: Y = a0 + a1X1 + a2X2 + …. + anXn

Donde n es la cantidad de rasgos. Xi los valores de los rasgos y aj los coeficientes calculados. Los coeficientes a0, a1,…., an se eligen de tal forma que se consiga la máxima separación entre las tres clases existentes, es decir, tratando de que los valores que toman estas funciones discriminantes Y en los tres grupos, sean lo más diferentes posibles. No haremos el desarrollo formal sobre la obtención de los coeficientes que definen las funciones discriminantes. Existen softwares de estadística que nos permiten realizar los cálculos, Ej: SPSS, MINITAB, XSLAT, STATISXL, y otros. La cantidad de funciones discriminantes que se obtiene es la cantidad de clases. En nuestro caso tendremos tres funciones discriminantes. Así, las funciones discriminantes serán de la forma:

Y1 = a10 + a11X1 + a12X2 + …. + a1nXn Y2 = a20 + a21X1 + a22X2 + …. + a2nXn Y3 = a30 + a31X1 + a32X2 + …. + a3nXn … Ym = am0 + am1X1 + am2X2 + …. + amnXn n: es la cantidad de rasgos m: es la cantidad de clases

6.8.2 Puntuaciones Discriminantes Son el resultado de evaluar cada una de las funciones discriminantes para un objeto em particular. O sea, a partir de los rasgos X1,...,Xn de um objeto, se evalúan todas las funciones discriminantes. Interpretación de las funciones discriminantes Una vez obtenidas las funciones discriminantes, nuestro objetivo es establecer la contribución relativa de los distintos rasgos a la discriminación, o lo que es lo mismo, determinar cuáles son los rasgos que más contribuyen a discriminar entre una clase y otra. 6.8.3 Coeficientes de las funciones La contribución de cada variable a la discriminación, se puede observar a través de los propios coeficientes (a1, a2,…,an) que definen a las funciones discriminantes. Por ejemplo, si en la función Y1, el coeficiente a11 que acompaña a la variable X1 fuera mucho mayor que los de las otras variables, podríamos pensar que esta variable X1 va a contribuir al valor final de Y1 en mayor medida que las otras variables, y por lo tanto es la más importante. Con un razonamiento similar podemos inferir que aquellas variables cuyos coeficientes tienen un valor “considerablemente” menor que el resto, contribuyan poco al valor de Y.

Sin embargo, esto no es del todo cierto, ya que las variables (X1,…,Xn) suelen medir magnitudes muy diferentes y/o venir expresadas en unidades distintas, lo cual dificulta su comparación. La solución es utilizar coeficientes estandarizados los cuales se calculan en base a los rasgos estandarizados. Los rasgos estandarizados no dependen de las unidades de medida y se calculan en base a la media y a la desviación típica de cada rasgo. Estos datos estadísticos también son brindados por los softwares estadísticos mencionados. Veamos el ejemplo de las figuras: Clases A (Objetos redondos) B (Objetos semi-alargados) C (Objetos alargados) Rasgos Diámetro Mayor Diámetro Menor Relación entre D.Mayor y D.Menor En este caso, intencionalmente hemos, utilizado dos rasgos (DMayor y DMenor) que no son importantes para la clasificación de los objetos. Suponemos que el rasgo importante es el tercero, el que cuyo valor nos da la relación entre los dos diámetros. El análisis discriminante, en su primera fase, nos ayudará a determinar cuáles variables son importantes y cuáles no. 6.8.4 Aprendizaje Para la fase de aprendizaje utilizaremos la matriz de aprendizaje de la Tabla 21.

Tabla 21. Matriz de Aprendizaje para el Análisis Discriminante

Al aplicar el análisis discriminante a estos datos obtenemos las funciones discriminantes que se observan en la Tabla 22:

Tabla 22. Funciones Discriminantes

Notar la diferencia significativa que existe entre los coeficientes correspondientes a la variable relac, que sabemos que es la importante y los coeficientes de las otras dos variables, que sabemos que no son importantes 6.8.5 Clasificación Para clasificar un nuevo objeto evaluamos cada una de las funciones discriminantes (hay una función para cada clase). Así obtenemos la Puntuación Discriminante del objeto para cada clase. El objeto pertenecerá a la clase cuya función haya dado como resultado La mayor puntuación discriminante Ejemplo: Queremos clasificar el objeto cuyos rasgos son:

DMay = 33, DMen = 14, Relac = 2.35 Evaluamos las tres funciones discriminantes Obteniendo

PD1 = 11.05 PD2 = 13.27 PD3 = -2.78 Significa que el objeto pertenece a la clase 2

6.9 Prototipos. Clasificación Supervisada

Los algoritmos basados en prototipos tratan, en la etapa de aprendizaje, de encontrar um subconjunto de objetos de la muestra que represente lo mejor posible a cada clase [7].

Em general, el problema consiste en: dada una muestra de objetos O1,…, Om Rn, encontrar un conjunto de vectores de referencia o centros de clusters c1,…, ck de forma tal que dividan el espacio original en subregiones de la forma:

Ri = { O Rn | d(O,ci) d(O,cj) j i }, estas regiones se denominan polígonos o polihedros de Voronoi. 6.9.1 Idea general de los métodos Buscan situar los ci de manera que “representen” lo mejor posible los datos originales. Esto es, situar los prototipos hacia donde están las mayores concentraciones de datos. El criterio estándar que se emplea es minimizar una función E con respecto al error cuadrático medio

Sean: ci = (ci1, …, ciN) Centroide de la clase i x = (x1, …, xN) Un objeto x de la clase i d(x,ci) = min ( d(x,cj) ) j = 1..k (k clases) De todas las distancias de un objeto de la clase j a los centroides, el valor mínimo es la distancia al centroide de esa clase. En general el problema se formula como: Minimizar, para k clases: E = Donde Pi es el conjunto de objetos de la clase i, cada uno representado por un vector x de N rasgos. Estos centroides ci representan lo mejor posible las muestras en el sentido de que la suma de los cuadrados de las longitudes de los vectores de error (x-ci) está minimizada. En la práctica, es probable que se necesite más de un centroide para una misma clase. Esto dependerá de la concentración de los datos, tal como se muestra en la Figura 17.

Figura 17.Centroides

6.9.2 Algoritmos de prototipos ó centroides Los algoritmos que se emplean para el cálculo de los ci funcionan, en general, como sigue: 1. Comienzan con una configuración arbitraria de los ci 2. Presentan uno a uno los objetos O del conjunto y actualizan los ci de acuerdo a cierta regla, que puede ser, por ejemplo:

e.o.c ),1t(

j(O)=i para 1)),(t(O*(t)+1)(t = (t)

i

ii

ic

cAcc

donde j(O) = clase del centroide mas cercano a O A(t) = función descendente de t.

k

1

2

)(i Pix

cix

En este paso se actualizan los centroides, tomando como base los objetos que estén más cercas a ellos 3. El paso 2. se repite un número grande de veces, o hasta que no haya cambios significativos en los ci Algunos algoritmos para la determinación de centroides ó prototipos: 1) Medios o Centros. Funciona creando prototipos a medida que se van necesitando. Si en el proceso de análisis de los elementos, encontramos uno que “no se parece” a ninguno de los prototipos existentes hasta ese momento, se crea un nuevo prototipo con ese elemento. Parte de un solo prototipo. 2) Convexos. Funciona uniendo prototipos. Si se encuentra que existen dos prototipos distintos en una misma clase que son “suficientemente parecidos”, entonces los une en un único prototipo nuevo. Parte de que todos los objetos son prototipos. 6.9.3 Algoritmo de Medios o Centros 1. Se parte de un único centroide (ej. El primer objeto) 2. Se recorren todos los objetos de la muestra. Sea cada uno Oi 3. Buscar el centroide más cercano a Oi ( Sea cs) 4. Si el centroide es de su misma clase, entonces:

actualizar el centroide como:

)(O*),d(O1

),d(O+= ss si

si

si cc

ccc

sino: crear un nuevo centroide igual a Oi Los pasos 2, 3 y 4. se repiten hasta que todos los objetos son más parecidos a un centroide de su misma clase (o sea, hasta que en una iteración no se creen nuevos prototipos) Este algoritmo obtiene un número de centroides que es mucho menor que la cantidad de objetos de la muestra de datos, pero tiene como desventajas que se requiere trabajar en un espacio métrico, los prototipos se crean en dependência del orden en que se tomen los objetos de la muestra de datos; pueden crearse centroides redundantes y los centroides pueden ser objetos no admisibles 6.9.4 Algoritmo de Convexos 1. Se parte de que todos los objetos de la muestra de datos son centroides. Al comienzo cada grupo tiene un solo elemento y coincide con el centroide del grupo. 2. Para cada grupo, encontrar un centroide de otro grupo que sea de la misma clase 3. Mezclar los dos grupos y calcular la nueva media o centroide del grupo resultante, así como su radio R (distancia del centroide al objeto más alejado del grupo) 4. Calcular la distancia d al centroide más cercano de otra clase 5. Si d > R, entonces (el nuevo grupo no interfiere con ningún grupo de otra clase)

-Aceptar la mezcla, eliminando los dos centroides de los dos grupos mezclados y dejando el nuevo centroide y grupo construido Sino: -Reponer los dos grupos originales -Pasar a mezclar con otro grupo de la misma clase, si no existe, cambiar el grupo de referencia en el paso 2. Los pasos 2, 3, 4 y 5 se repiten hasta que en una iteración no se pueda mezclar ningún grupo Este algoritmo obtiene un número casi óptimo de prototipos ó centróides, pero tiene como desventaja que se requiere trabajar en un espacio métrico, los prototipos se crean en dependência del orden en que se tomen los objetos de la muestra de datos y el algoritmo de formación de prototipos es lento. 6.9.5 Clasificación Una vez encontrados los prototipos ó centroides de las clases el proceso de clasificación es similar al del algoritmo NN, en el que el objeto a clasificar se compara con todos los de la muestra (en este caso los prototipos) y se determina el más cercano y así la clase a la que pertenece. 6.9.6 Implementación del Algoritmo: Medios ó Centros Estructuras de datos: Matriz: Objetos(1..N,0..R) N Objetos R Rasgos (1..R, Posición 0 será para la clase) Es la matriz con los datos de los objetos de la muestra Matriz: Centroides(1..N,0..R) Es la matriz donde quedarán los Centroides calculados. La cantidad de centroides será <= N Usaremos nCent, para indicar esa cantidad Funciones: RestaVector( vec1(0..R), vec2(0..R), res(0..R) )

SumaVector( vec1(0..R), vec2(0..R), res(0..R) )

MultEscalarVector( vec(0..R), escalar, res(0..R) )

Distancia( vec1(0..R), vec2(0..R) )

MatrizAVector( matriz(1..N,0..R), fila, vecD(0..R) )

VectorAMatriz( vecF(0..R), matriz(1..N,0..R), fila )

MasCercano( vec(0..R) )

Algoritmo principal nCent = 1

MatrizAVector objetos, 1, vector

VectorAMatriz vector, centroides, 1

For i = 2 To N

MatrizAVector objetos, i, vector

pcs = MasCercano(vector)

If centroides(pcs, 0) = vector(0) Then

' actualizar centroide

MatrizAVector centroides, pcs, cs

RestaVector vector, cs, resta

d = distancia(vector, cs)

d = d / (1 + d)

MultEscalarVector resta, d, result

SumaVector cs, result, nuevocs

nuevocs(0) = cs(0)

VectorAMatriz nuevocs, centroides, pcs

Else

' nuevo centroide

nCent = nCent + 1

VectorAMatriz vector, centroides, nCent

End If

Next

Funciones RestaVector( vec1, vec2, res)

For i = 1 To R

res(i) = vec1(i) - vec2(i)

Next

SumaVector( vec1, vec2, res)

For i = 1 To R

res(i) = vec1(i) + vec2(i)

Next

MultEscalarVector( vector, e, vecD )

For i = 1 To R

vecD(i) = vector(i) * e

Next

MatrizAVector( matriz, fila, vecD )

For i = 0 To R

vecD(i) = matriz(fila, i)

Next

VectorAMatriz( vecF, matriz, fila)

For i = 0 To R

matriz(fila, i) = vecF(i)

Next

Distancia( vec1, vec2 )

RestaVector vec1, vec2, res

r = 0

For i = 1 To R

r = r + res(i) ^ 2

Next i

r = r ^ 0.5

distancia = r

MasCercano( vector )

posMenor = 1

dMenor = 10000

For i = 1 To nCent

MatrizAVector centroides, i, vec2

d = distancia(vector, vec2)

If d < dMenor Then

posMenor = i

Menor = d

End If

Next

MasCercano = posMenor

CAPÍTULO VII: REDES NEURONALES ARTIFICIALES

8.1 Introducción

Las Redes Neuronales Artificiales o Modelos Conexionistas se han desarrollado con el fin de usar la organización y los principios de procesamiento de la información del cerebro humano. A pesar de que las neuronas del cerebro tienen una velocidad de cálculo lenta, en determinados problemas logran alcanzar una velocidad alta de procesamiento y realizar las operaciones varias veces más rápido que las computadoras, dada su arquitectura específica y sobre todo al paralelismo con que trabajan [9]. Los sistemas de computación basados en el modelo secuencial desarrollado por Von Neuman son exitosos en: Resolución de problemas matemáticos o científicos Creación, manipulación y mantenimiento de bases de datos Comunicaciones electrónicas Procesamiento de textos, gráficos y auto edición Funciones de control de electrodomésticos Etc. Sin embargo estos sistemas tienen una gran incapacidad para interpretar el mundo . El cerebro humano cuenta con varias características deseables para cualquier sistema de procesamiento digital, tales como: 1. Es robusto y tolerante a fallas, diariamente mueren neuronas sin afectar su desempeño. 2. Es flexible, se ajusta a nuevos ambientes por aprendizaje, no hay que programarlo. 3. Puede manejar información difusa, con ruido o inconsistente. 4. Es altamente paralelo 5. Es pequeño, compacto y consume poca energía Basados en la eficiencia de los procesos llevados a cabo por el cerebro, e inspirados en su funcionamiento, varios investigadores han desarrollado la teoría de las Redes Neuronales Artificiales (RNA) Las RNA emulan las redes neuronales biológicas. Se han utilizado para aprender estrategias de solución basadas en ejemplos de comportamiento típico de patrones. Son sistemas que no requieren que la tarea a ejecutar se programe, ellos generalizan y aprenden de la experiencia

8.2 Breve historia de las RNA

Los primeros resultados aparecieron desde los inicios ciencia de la inteligencia artificial [9]. El llamado período clásico de las RNA en el que se desarrolló el modelo Perceptron,

por Rosenblatt en 1958. Imitaba fuertemente a una neurona y tenía un algoritmo de aprendizaje Una década después Minsky y Papert expusieron las limitaciones de este tipo de redes neuronales en su famoso libro Perceptrons, y comenzó entonces la época oscura en la investigación de las redes neuronales Durante el período oscuro hubo ausencia de publicaciones o discusiones sobre el tema. Se desarrollaron trabajos de importancia fundamental para el futuro de las redes neuronales, sólo que se hicieron con reserva En junio de 1987 hubo una amplia participación en la Conferencia Internacional sobre Redes Neuronales auspiciada por la IEEE. Se presentaron trabajos como el Modelo “Adaptive Resonance Theory (ART)” (Steven Grossberg y Gail Carpenter), el Modelo “Self-Organizing Maps” (Teuvo Kohonen), el algoritmo de aprendizaje con propagación de los errores hacia atrás -Backpropagation- (Werbos descubrió el principio matemático que permitió desarrollarlo)

8.3 Algunas aplicaciones de las RNA:

Procesamiento de imágenes y de voz Reconocimiento de patrones (Clasificación, Clustering) Planeamiento Interfaces adaptativas para sistemas Hombre/Máquina Predicción Modelamiento Optimización Aprendizaje asociativo Filtrado de señales Características de las RNA No ejecutan instrucciones. Responden en paralelo a las entradas que se les presenta. El conocimiento de una red neuronal no se almacena en instrucciones El poder de la red está en su topología y en los valores de las conexiones (pesos) entre neuronas. Las RNA son una teoría que aún esta en proceso de desarrollo. Su verdadera potencialidad no se ha alcanzado todavía; aunque los investigadores han desarrollado potentes algoritmos de aprendizaje de gran valor práctico, las representaciones y procedimientos de que se sirve el cerebro, son aún desconocidas

8.4 Neuronas biológicas

La Figura 18 muestra la estructura de una neurona biológica. Dendritas: Son el árbol receptor de la red, son como fibras nerviosas que cargan de señales eléctricas el cuerpo de la célula.

Cuerpo de la célula: Realiza la suma de esas señales de entrada. Axón: es una fibra larga que lleva la señal desde el cuerpo de la célula hacia otras neuronas. Sinápsis: Punto de contacto entre un axón de una célula y una dendrita de otra célula.

Figura 18. Neurona Biológica

8.5 Neuronas artificiales

De la observación detallada del proceso biológico se han hallado los siguientes análogos con el sistema artificial, como se muestran en la Figura 19.

Figura 19. Neurona Biológica y Neurona Artificial

Las entradas Xi representan las señales que provienen de otras neuronas y que son capturadas por las dendritas. Los pesos Wi son la intensidad de la sinápsis que conecta dos neuronas; tanto Xi como Wi son valores reales O, es la función umbral que la neurona debe sobrepasar para activarse; este proceso ocurre biológicamente en el cuerpo de la célula. Las señales de entrada a una neurona artificial

X1, X2,.., Xn , son variables continuas Cada señal de entrada pasa a través de una ganancia o peso, llamado peso sináptico o fortaleza de la conexión Los pesos pueden ser positivos (excitatorios), o negativos (inhibitorios) El nodo sumatorio acumula todas las señales de entradas multiplicadas por los pesos o ponderadas y las pasa a la salida a través de una función umbral o función de transferencia. La entrada neta a cada unidad puede escribirse de la siguiente manera: Un esquema más resumido se ilustra en la Figura 20:

Figura 20. Elementos de una neurona artificial

p: Vector de Entrada W: Vector de pesos b: bias. Ganancia que refuerza la salida de la neurona. n: Es la salida neta de la neurona; a: Es la salida total. Está determinada por la función de transferencia f: Función de transferencia. Puede ser una función lineal o no lineal de n, y que es escogida dependiendo de las especificaciones del problema que la neurona tenga que resolver.

8.6 Especificación de una RNA

Se requiere definir tres elementos: 1 - Modelo de neurona (función de transferencia que determina la respuesta de las neuronas) 2 - Topología (organización de la colección de neuronas) 3 - Algoritmo ó ley de aprendizaje (algoritmo para el cálculo de los pesos de las conexiones)

8.7 Clasificación general de las RNA

La Figura 21, muestra los modelos de redes más utilizados, clasificados en dependencia del tipo de entrada y de el tipo de aprendizaje

Figura 21. Clasificación de redes neuronales

8.8 Modelos de neurona (Funciones de transferencia)

La Tabla 23, muestra los modelos de neurona mas frecuentemente utilizados. Se muestra una descripción del modelo ó función, la función matemática y el ícono que gráficamente se utiliza al dibujar la red.

Tabla 23. Modelos de Redes Neuronales

Limitador fuerte (hardlim): acerca la salida de la red a cero, si el argumento de la función es menor que cero y la lleva a uno si este argumento es mayor ó igual que cero. esta función crea neuronas que clasifican las entradas en dos categorías diferentes, característica que le permite ser empleada en la red tipo perceptrón

Limitador fuerte simétrica (Hardlims): Similar al Hardlim, pero restringe el espacio de salida a valores entre 1 y –1

Función de transferencia lineal (purelin): La salida de la función es igual a la entrada. Neuronas que emplean esta función de transferencia son utilizadas en la red tipo Adaline.

a = n

Función de transferencia sigmoidal (logsig): Esta función toma los valores de entrada, los cuales pueden oscilar entre mas y menos infinito, y restringe la salida a valores entre cero y uno, de acuerdo a la expresión. Comúnmente usada en redes multicapa, como la Backpropagation.

8.9 Topologías de RNA

a) Neurona Simple. La expresión más simplificada de una red es aquella en la cual se tiene solamente una neurona. Esta funciona como una unidad de procesamiento que recibe entradas y calcula un nivel de activación que definirá su respuesta. Un ejemplo de esta arquitectura es la neurona modelo de McCulloch y Pitts, que se muestra en la Figura 22.

x1

x2

x3

w2

w3

w1

x0

w0 (bias)

Figura 22. Neurona Simple

b) Red Simple. Se organiza un conjunto de N neuronas de la forma siguiente: Se utilizan M unidades sensoras, las cuales captan la información de entrada, estas M unidades se conectan a las N neuronas mediante caminos pesados. No existe conexión entre las neuronas. Cada neurona calcula una respuesta, y la salida de la red será un vector con N componentes, una por cada neurona, como se muestra en la Figura 23.

x1

x2

x3

wa1

wa2

wb1

wb2

wc1

wc2

a

b

c

1

2

Figura 23. Red Simple

c) Red con elementos de asociación. La arquitectura anterior se puede desarrollar introduciendo un conjunto de unidades de asociación en las cuales se combinan las entradas (pueden utilizarse para esto operadores lógicos) y las combinaciones producidas sirven de entrada a las neuronas, las cuales calculan las salida de la red. Esta topología es muy similar a la arquitectura propuesta originalmente para el Perceptron. Se puede observar en la Figura 24.

2

1

S0

S1

S2

a

b

wa1

wa2

wb1

wb2

Figura 24. Red con elementos de asociación

d) Red multicapa. Una de las topologías más poderosas y difundidas. Ordena el conjunto de elementos de procesamiento en niveles, de modo que los enlaces se establecen desde unidades en el nivel i a unidades en el nivel j (i<j), por lo que la información fluye unidireccionalmente desde las unidades de entrada a las unidades de salida Típicamente existe una capa de unidades sensoras, una o más capas ocultas de neuronas, y una capa de neuronas que producen la salida. El calificativo de oculta es para denotar que ellas permanecen "desconocidas" para el usuario de la red. Esta topología se puede observar en la Figura 25. Se utilizan algoritmos de aprendizaje como el de propagación de los errores hacia atrás (backpropagation). Esta topología es la base del Multilayer Perceptron y del modelo MADALINE. Resulta de interés analizar lo referente a cuántos niveles o capas, así como la cantidad de neuronas por capas, son necesarios: -En el nivel inicial existe una unidad sensora por cada rasgo de entrada a la red -En la capa de salida se colocan tantas neuronas como sean necesarias.

-Se ha probado que dos capas ocultas son suficientes para resolver cualquier problema. -No existe un criterio riguroso para determinar la cantidad de neuronas en las capas ocultas

capa oculta

capa de salida capa de entrada

vector de entrada

x

vector

de salida

Figura 25. Red multicapa

e) Modelo interactivo: Se tiene un conjunto de N neuronas las cuales se conectan completa y mutuamente, es decir, todas las unidades sirven como unidades de entrada y como neuronas para calcular la salida; cada neurona se conecta a las N-1 restantes mediante caminos pesados. El procedimiento de cálculo de las salidas se realiza mediante un procedimiento iterativo en el cual las neuronas se inicializan con los valores de entrada y recalculan estos valores hasta caer en un estado estable. La red de Hopfield y el modelo con activación interactiva y competencia se basan en esta topología, ilustrada en la Figura 26.

a b c d

wac

wad

wbd

wab wbc wcd

Figura 26. Modelo interactivo

Ejemplo del robot La descripción del funcionamiento del robot es similar a la del ejemplo de Agentes Reactivos. Diseño de la RNA Utilizaremos una red con elementos de asociación, como se muestra en la Figura 27- S1, S2, S3, S4, S5 S6, S7, S8: Representan las entradas

X1, X2, X3, X4: Representan las neuronas de la primera capa (elementos de asociación) E, S, O, N, D: Representan las neuronas de la salida (Este, Sur, Oeste, Norte, Defecto)

Figura 27. Topología de la Red para el Robot

Pesos de las conexiones De las unidades sensoras Si a las Neuronas Xj Teniendo en cuenta que: X1 = S2 ó S3 X2 = S4 ó S5 X3 = S6 ó S7 X4 = S8 ó S1 Definimos pesos positivos (1) para las conexiones de la unidad sensora a la neurona para la cual contribuye su valor, y cero para las demás Ejemplo: El valor que tomará la Neurona X1 será 1 ó 2, si S2 ó S3 son iguales a 1. Las conexiones de S2 y S3 para el resto de las neuronas es 0, como se muestra en la Figura 28.

Figura 28. Pesos entra la capa de entrada y la intermedia

Pesos de las conexiones De las Neuronas Xi a las de Salida Para determinar estos pesos, primero analizaremos la función de transferencia. Necesitamos que la función de transferencia nos dé como resultado para cada neurona:

1 si hay que tomar la dirección que indica la neurona ó 0 si no Usaremos la función de tipo hardlim 1 si (neta+bias) > 0 f(neta+bias) = 0 si (neta+bias) <= 0 Necesitamos entonces que los pesos desde las Neuronas Xi a las de Salida (E,S,O,N,D) nos brinden un valor Positivo para la neurona que indica el movimiento que debe realizarse y 0 ó Negativo para las demás Para ello analizamos los posibles movimientos: Si X1 y !X2 mover al Este Si X2 y !X3 mover al Sur Si X3 y !X4 mover al Oeste Si X4 y !X1 mover al Norte Veamos el caso de mover la este: Si X1 y !X2 mover al Este Los casos que tendríamos son: a) X1 = 1 (ó 2) y X2 = 0 (se mueve al este) b) X1 = 1 (ó 2) y X2 = 1 (ó 2) (no se mueve al este) c) X1 = 0 y X2 = 0,1,2 (no se mueve al este) Podemos notar que: Es importante que X1 sea distinto de cero e importante (pero negativamente) que X2 sea distinto de 0. Podríamos definir entonces el peso de X1 a E = 1, y el peso de X2 a E = -2 Para los tres casos, los posibles valores para neta(E) serían: a) 1, 2 b) -1, -3, 0, -2 c) 0, -2, -4 En general, si la regla de movimiento es: Xi y ! Xj mover a K Entonces los pesos serían: De Xi a K = 1 De Xj a K = -2 Finalmente nos queda la Neurona D (movimiento por defecto) Esta neurona se activará cuando todas las Xi sean 0, por tanto, si alguna de ellas es distinta de 0 su (neta+bias) debe ser negativo. Luego le colocamos a todas las Xi el valor -2 en su conexión con D, y le asignamos un bias de 1 a D, para que cuando todas sean 0, la neurona tome valor 1. La Figura 29 muestra los pesos entre las Neuronas X1 y X2 y la capa de Salida.

Figura 29. Pesos entre la capa intermedia y la de salida

Codificación en Visual Basic: Dim S(1 To 8) (unidades sensoras, S)

Dim X(1 To 4) (neuronas Xi)

Dim W1(1 To 8, 1 To 4) (pesos de S a X)

Dim W2(1 To 4, 1 To 5) (pesos de X a salida)

Dim bias(1 To 5) (bias de la salida)

Dim neta(1 To 5) (neta de la salida)

Dim salida(1 To 5) (neuronas de salida)

Todos serían arrays de tipo Entero Inicializar las matrices de pesos: W1(1, 1) = 0: W1(1, 2) = 0: W1(1, 3) = 0: W1(1, 4) = 1

W1(2, 1) = 1: W1(2, 2) = 0: W1(2, 3) = 0: W1(2, 4) = 0

W1(3, 1) = 1: W1(3, 2) = 0: W1(3, 3) = 0: W1(3, 4) = 0

W1(4, 1) = 0: W1(4, 2) = 1: W1(4, 3) = 0: W1(4, 4) = 0

W1(5, 1) = 0: W1(5, 2) = 1: W1(5, 3) = 0: W1(5, 4) = 0

W1(6, 1) = 0: W1(6, 2) = 0: W1(6, 3) = 1: W1(6, 4) = 0

W1(7, 1) = 0: W1(7, 2) = 0: W1(7, 3) = 1: W1(7, 4) = 0

W1(8, 1) = 0: W1(8, 2) = 0: W1(8, 3) = 0: W1(8, 4) = 1

W2(1, 1) = 1: W2(1, 2) = 0: W2(1, 3) = 0: W2(1, 4) = -2: W2(1, 5) = -2

W2(2, 1) = -2: W2(2, 2) = 1: W2(2, 3) = 0: W2(2, 4) = 0: W2(2, 5) = -2

W2(3, 1) = 0: W2(3, 2) = -2: W2(3, 3) = 1: W2(3, 4) = 0: W2(3, 5) = -2

W2(4, 1) = 0: W2(4, 2) = 0: W2(4, 3) = -2: W2(4, 4) = 1: W2(4, 5) = -2

bias(1) = 0: bias(2) = 0: bias(3) = 0: bias(4) = 0: bias(5) = 1

Ejecutar la RNA: For i = 1 To 4

X(i) = 0

For j = 1 To 8

X(i) = X(i) + S(j) * W1(j, i)

Next j

Next i

For i = 1 To 5

neta(i) = 0

For j = 1 To 4

neta(i) = neta(i) + X(j) * W2(j, i)

Next j

Next i

For i = 1 To 5

If neta(i)+bias(i) > 0 Then

salida(i) = 1

Else

salida(i) = 0

End If

Next i

8.10 Aprendizaje supervisado. Perceptrón

8.10.1 Aprendizaje de las RNA El aprendizaje se manifiesta en el proceso de cambiar la fortaleza de las conexiones entre las neuronas (cálculo de los pesos) Existen dos vías: Aprendizaje No adaptativo: Se determina de antemano cual será el valor de los pesos. Aprendizaje Adaptativo: No existe una forma para determinar de antemano los pesos, por lo que se necesita un proceso iterativo: Wi(t) = Wi(t-1) + ΔWi El aprendizaje adaptativo es sin lugar a dudas el mas importante dado que es la situación que casi en un 100% de problemas, se da. Se tiene la información sobre los rasgos de un conjunto de objetos y se necesita, a partir de ellos, determinar los pesos de la red. Se plantean tres interrogantes al respecto: 1) ¿Cómo calcular los ΔWi en cada iteración? 2) ¿Cuántas iteraciones realizar? 3) ¿Con qué valor comenzar los Wi(0)? El aprendizaje de las RNA puede ser: Supervisado: Tenemos un conjunto de objetos con su descripción completa (rasgos y clase a que pertenecen) (Conjunto de entrenamiento) No supervisado: Tenemos un conjunto de objetos con su descripción incompleta (típicamente desconocemos las clases en que se pueden agrupar: Problema de Clustering) 8.10.2 Red Perceptrón Características

Sus entradas son números reales. Posee un algoritmo de aprendizaje supervisado. Tiene como restricción de que el espacio de ser linealmente separable [9]. Breve Historia La primera red neuronal conocida. Fue desarrollada en 1943 por Warren McCulloch y Walter Pitts. Suma de las señales de entrada, multiplicadas por unos valores de pesos escogidos aleatoriamente. La entrada es comparada con un patrón preestablecido para determinar la salida de la red. Si en la comparación, la suma de las entradas multiplicadas por los pesos es mayor o igual que el patrón preestablecido la salida de la red es uno (1), en caso contrario la salida es cero (0 ó -1). La red tipo Perceptrón fue inventada por el psicólogo Frank Rosenblatt en el año 1957. El primer modelo de Perceptrón fue desarrollado en un ambiente biológico imitando el funcionamiento del ojo humano. El fotoperceptrón: era un dispositivo que respondía a señales ópticas. Inicialmente un dispositivo de aprendizaje. En su configuración inicial no estaba en capacidad de distinguir patrones de entrada muy complejos. Sin embargo mediante un proceso de aprendizaje era capaz de adquirir esta capacidad. En esencia, el entrenamiento implicaba un proceso de refuerzo mediante el cual la salida de las unidades se incrementaba o se decrementaba dependiendo de si las unidades contribuían o no a las respuestas correctas del Perceptrón para una entrada dada. En 1969 Marvin Minsky y Seymour Papert publicaron su libro: “Perceptrons: An introduction to Computational Geometry”, el cual contenía un análisis detallado del Perceptrón, en términos de sus capacidades y limitaciones. 8.10.3 Modelo de neurona del Perceptrón El modelo de neurona ó función de transferencia es de tipo hardlim: 1 si (neta+bias) > 0 f(neta+bias) = 0 si (neta+bias) <= 0 También puede utilizarse una función de transferencia tipo hardlims (salidas 1 ó -1) 8.10.4 Topología del Perceptrón La topología es la de una neurona simple, como se ilustra en la Figura 30. La neurona de salida realiza la suma ponderada de las entradas, suma el bias y pasa el resultado a una función de transferencia de tipo hardlim(s). La regla e decisión es responder +1 si el patrón presentado pertenece a la clase A, ó 0(–1) si el patrón pertenece a la clase B.

Figura 30. Topología del Perceptrón

8.10.4 Regla de aprendizaje del Perceptrón El Perceptrón es un tipo de red de aprendizaje supervisado, es decir necesita conocer los valores esperados para cada una de las entradas presentadas; su comportamiento está definido por pares de esta forma:

Cuando pj es aplicado a la red, la salida de la red es comparada con el valor esperado tj Recordemos que la salida de la red esta determinada por:

a = f( XiWi + bias) = hardlim(XiWi + bias) 8.10.5 Algoritmo general de aprendizaje 1) Se inicializa la matriz de pesos y el valor del bias, por lo general se asignan valores aleatorios a cada uno de ellos. 2) Se presentan todos los patrones a la red y se calcula la salida de la red por medio de

a = f( XiWi + bias) donde f puede ser la función hardlim o hardlims 3) Cuando la red no retorna la salida correcta, es necesario alterar el valor de los pesos, tratando de llevarlo hasta p y así aumentar las posibilidades de que la clasificación sea correcta, una posibilidad es adicionar p a w haciendo que el vector w apunte en la dirección de p, y de esta forma después de repetidas presentaciones de p a la red, w se aproximará a p. En general: El valor a correspondiente a la aplicación del objeto p a la red constituye la clasificación (o salida) de la red para p. Este valor puede ser igual a t (la clasificación real de p) ó diferente.

Si son iguales significa que la red ha brindado el valor correcto para p, de lo contrario la red se ha “equivocado” Los posibles casos son los siguientes: 1) a = t La salida de la Red es igual a la clasificación de p por tanto funcionó correctamente y no hay que hacer cambios en los pesos 2) t = 1 y a = 0 (ó -1) 3) t = 0 (ó -1) y a = 1 En los dos últimos casos la red se ha equivocado por tanto sería necesario modificar los pesos (aprender) Las acciones para el aprendizaje, en cada caso serían: 1. t = a WN = WA 2. t=1, a=0 WN = WA + p 3. t=0, a=1 WN = WA – p Simplificaremos los casos haciendo: e = t - a 1. e = 0 WN = WA 2. e = 1 WN = WA + p 3. e = -1 WN = WA – p En general: WN = WA + e * p BiasN = BiasA + e Si se utiliza como función de transferencia la de tipo Hardlims (salidas: 1 y -1) entonces los valores de e son: 0, 2, y -2 Ejemplo: Utilizaremos cuatro puntos para el aprendizaje de la RNA, como se muestran en la Figura 31 P1 = ( 2, 1) T1 = 1 (clase A) P2 = ( 0, -1) T2 = 1 (clase A) P3 = (-2, 1) T3 = -1 (clase B) P4 = ( 0, 2) T4 = -1 (clase B)

Figura 31. Objetos en R2, separados en 2 clases

Partimos de cualquier valor (aleatorios) para los pesos y el bias: W = ( -0.7, 0.2 ) bias = 0.5 En este caso se utilizará la función hardlims (1, -1) Procedimiento general: El procedimiento de aprendizaje de la red (ajuste de los pesos) se resume en aplicar cada objeto de la muestra a la red y ajustar los pesos en caso de que la salida de la red no sea correcta, de acuerdo a las fórmulas ya explicadas: WN = WA + e * p BiasN = BiasA + e Donde e = t-a t = valor real del objeto a = valor calculado por la Red Paso 1. Objeto P1 = (2,1) T1 = 1 W = ( -0.7, 0.2 ) bias = 0.5 Aplicamos la Red para P1 neta+bias = -0.7*2 + 0.2*1 + 0.5 = -0.7 a = hardlims(-0.7) = -1 T1 = 1 ≠ a = -1 Por tanto es necesario ajustar los pesos: e = T1 – a = 1 – (-1) = 2 WN = W + e*P1 = (-0.7,0.2) + 2*(2,1) WN = (3.3, 2.2) biasN = bias + e = 0.5 + e = 2.5 Paso 2. Objeto P2 = (0,-1) T2 = 1 W = ( 3.3, 2.2 ) bias = 2.5

Aplicamos la Red para P2 neta+bias = 3.3*0 + 2.2*-1 + 2.5 = 0.3 a = hardlims(0.3) = 1 T2 = 1 = a = 1 Por tanto no es necesario ajustar los pesos Paso 3. Objeto P3 = (-2,1) T3 = -1 W = ( 3.3, 2.2 ) bias = 2.5 Aplicamos la Red para P3 neta+bias = 3.3*-2 + 2.2*1 + 2.5 = -1.9 a = hardlims(-1.9) = -1 T3 = -1 = a = -1 Por tanto no es necesario ajustar los pesos Paso 4. Objeto P4 = (0,2) T4 = -1 W = ( 3.3, 2.2 ) bias = 2.5 Aplicamos la Red para P4 neta+bias = 3.3*0 + 2.2*2 + 2.5 = 6.9 a = hardlims(6.9) = 1 T4 = -1 ≠ a = 1 Por tanto es necesario ajustar los pesos: e = T1 – a = -1 – (1) = -2 WN = W + e*P4 = (3.3,2.2) + -2*(0,2) WN = (3.3, -1.8) biasN = bias + e = 2.5 + e = 0.5 Hemos concluido con todos los objetos de la muestra. El proceso se repite con todos los objetos de la muestra hasta que: a) La red responda correctamente para todos los objetos, ó b) Se alcance un número determinado de iteraciones En el ejemplo, se da la situación a) RNA(P1) = 1 = T1 = 1 ( neta+bias = 5.3 ) RNA(P2) = 1 = T2 = 1 ( neta+bias)= 2.3 ) RNA(P3) = -1 = T3 = -1 ( neta+bias = -7.9 ) RNA(P4) = -1 = T4 = -1 ( neta+bias = -3.1 ) La red final quedaría con la siguiente configuración y se ilustra en la Figura 32.

W = (3.3, -1.8) bias 0.5

Figura 32. Red final. Perceptrón

8.10.6 Limitación del Perceptrón Este tipo de red puede resolver solamente problemas cuyas salidas estén clasificadas en dos categorías diferentes y que permitan que su espacio de entrada sea dividido en regiones linealmente separables El proceso para determinar si un problema es linealmente separable o no, se realiza gráficamente sin problema, cuando los patrones de entrada generan un espacio de dos dimensiones, como en el caso del ejemplo; sin embargo, esta visualización se dificulta cuando el conjunto de patrones de entrada es de tres ó más dimensiones, y resulta imposible de observar gráficamente cuando los patrones de entrada son de dimensiones superiores; en este caso se requiere plantear condiciones de desigualdad que permitan comprobar la separabilidad lineal de los patrones, esto se realiza con base en la ecuación de salida del Perceptrón: W*P+Bias >= 0 para los Objetos P, clasificados como 1 W*P+Bias < 0 para los Objetos P, clasificados como 0 (-1)

8.11 Aprendizaje no supervisado. Redes competitivas

8.11.1 Introducción En este tipo de redes las neuronas compiten (y cooperan) unas con otras con el fin de llevar a cabo una tarea dada. Se pretende que cuando se presente a la red cierta información de entrada, sólo una de las neuronas de salida de la red se active (alcance su valor de respuesta máximo). Las neuronas compiten para activarse quedando finalmente una, como neurona vencedora y el resto quedan anuladas y siendo forzadas a sus valores de respuesta mínimos. El objetivo de este aprendizaje es categorizar los datos que se introducen en la red (formar clusters). Informaciones similares son clasificadas en la misma categoría y por tanto deben activar la misma neurona de salida. Las clases o categorías son creadas por la propia red, por lo que se trata de un aprendizaje no supervisado a través de las correlaciones entre los datos de entrada. 8.11.2 Breve historia

A principios de 1959, Frank Rosenblatt creó un simple clasificador (una red de aprendizaje no supervisado) basado en el Perceptrón, el cual aprendía a clasificar vectores de entrada en dos clases con igual número de rasgos A finales de los años 60 y principios de los 70, Stephen Grossberg introdujo redes competitivas. Algunos de los comportamientos útiles obtenidos por él, fueron la supresión del ruido, aumento del contraste y normalización de vectores En 1973, Christoph Von Der Malsburg introduce la regla del mapa de organización propia, que permitía a la red clasificar entradas en las cuales las neuronas que estuviesen en un vecindario cercano a la neurona ganadora, respondieran a entradas similares Grossberg extendió el trabajo de Von Der Malsburg, redescubriendo la regla Instar. Mostró que la regla Instar eliminó la necesidad de renormalizar los pesos, porque los vectores de pesos que aprendían a reconocer vectores de entrada normalizados, automáticamente se normalizarán ellos mismos Tuevo Kohonen. Su mayor aporte ha sido en aplicaciones para ingeniería y en descripciones de eficiencia matemática de las redes. Durante la década de los 70 Kohonen desarrolló una versión simplificada de la regla Instar, inspirada también en la red de Von Der Malsburg y Grossberg, de esta forma encontró una manera muy eficiente de incorporar topología a una red competitiva 8.11.3 Redes Competitivas En estas redes cada neurona tiene asignado un peso total (neta: suma de todos los pesos de las conexiones que tiene a su entrada) El aprendizaje afecta sólo a las neuronas ganadoras en las que se redistribuye el peso total entre sus conexiones y se sustrae una porción de los pesos de todas las conexiones que llegan a la neurona vencedora, repartiendo esta cantidad por igual entre todas las conexiones procedentes de unidades activas. La variación del peso de una conexión entre una unidad i y otra j será nula si la neurona j no recibe excitación por parte de la neurona i y se modificará (se reforzará) si es excitada por dicha neurona. 8.11.4 Red de Kohonen Existen evidencias que demuestran que en el cerebro hay neuronas que se organizan en muchas zonas, de forma que las informaciones captadas del entorno a través de los órganos sensoriales se representan internamente en forma de mapas bidimensionales. Aunque en gran medida esta organización neuronal está predeterminada genéticamente, es probable que parte de ella se origine mediante el aprendizaje, esto sugiere que el cerebro podría poseer la capacidad inherente de formar mapas topológicos de las informaciones recibidas del exterior A partir de estas ideas Tuevo Kohonen presentó en 1982 un sistema con un comportamiento semejante, se trataba de un modelo de red neuronal con capacidad para formar mapas de características de manera similar a como ocurre en el cerebro

Este modelo tiene dos variantes denominadas LVQ (Learning Vector Quantization) y TPM (Topology Preserving Map) o SOM (Self Organizing Map), ambas se basan en el principio de formación de mapas topológicos para establecer características comunes entre las informaciones (vectores) de entrada a la red, aunque difieren en las dimensiones de éstos, siendo de una sola dimensión en el caso de LVQ y bidimensional ó mayor en la red SOM. 8.11.5 Topología La topología de la red de Kohonen se ilustra en la Figura 33.

Figura 33. Topología de la Red de Kohonen

Se distingue: -Etapa de aprendizaje -Etapa de funcionamiento 8.11.6 Etapa de Aprendizaje (no supervisado) Se fijan los valores de las conexiones. Las neuronas de la capa de salida compiten por activarse y sólo una de ellas permanece activa ante una determinada información de entrada a la red, los pesos de las conexiones se ajustan en función de la neurona que haya resultado vencedora. Se presenta a la red los vectores de entrada (entrenamiento) para que ésta establezca en función de la semejanza entre los datos, las diferentes categorías, que servirían durante la fase de funcionamiento para realizar clasificaciones de nuevos datos que se presenten a la red. Los valores finales de los pesos de las conexiones entre cada neurona de la capa de salida con las de entrada se corresponderán con los valores de los componentes del vector de aprendizaje que consigue activar la neurona correspondiente.

EL aprendizaje no concluye después de presentarle una vez todos los patrones de entrada, sino que habrá que repetir el proceso varias veces para refinar el mapa topológico de salida, de tal forma que cuantas más veces se presenten los datos, tanto más se reducirán las zonas de neuronas que se deben activar ante entradas parecidas, consiguiendo que la red pueda realizar una clasificación mas selectiva Zona de Vecindad: Es la zona de vecindad, o vecindario alrededor de la neurona vencedora i*, los pesos de las neuronas que se encuentren en esta zona a la que se le dará el nombre de X(q), serán actualizados junto con el peso de la neurona ganadora 8.11.7 Algoritmo de Aprendizaje Partimos de: M: Neuronas de salida organizadas bidimensionalmente. Se determinan las distancias entre cada una de ellas en el espacio bidimensional N: Neuronas de entrada (N rasgos) O: Conjunto de objetos del entrenamiento (O1, O2, .. OP). Cada objeto es un vector de N componentes (rasgos) W: Matriz de pesos MxN (ó NxM) 1) Se inicializan los pesos (Wij) con valores aleatorios pequeños y se fija la zona de vecindad entre las neuronas de salida. 2) Se presentan a la red todos los objetos del entrenamiento (k=1 hasta P) : Ok = (r1, r2, .., rN) Ok El Objeto que se presenta (r1, r2, .., rN) Rasgos del objeto 3) Para el objeto Ok se determina la neurona vencedora de la capa de salida: Es aquella neurona cuyo vector de pesos W (pesos de las conexiones entre esa neurona y cada una de las neuronas de la capa de entrada) sea el más parecido al vector de entrada (Distancia Euclidiana (sin raíz))

Se determina el menor de los di. Con lo cual determinamos la neurona ganadora (i).

4) Se actualizan los pesos de las conexiones entre: -Las neuronas de entrada y la neurona ganadora (i) -Las neuronas de entrada y las neuronas vecinas de la ganadora w(q)= w(q-1) + a(q) ( Oiv - w(q-1) ) Se aplica para todas las neuronas que están en la vecindad de la ganadora. El tamaño de la vecindad se puede reducir en cada iteración del proceso de ajuste de los pesos, con lo que el conjunto de neuronas que pueden considerarse vecinas cada vez es menor; sin embargo en la práctica es habitual considerar una zona fija en todo el proceso de entrenamiento de la red Zona de Vecindad Puede variarar ó mantenerse fijo durante todo el entrenamiento q: Indica la iteración a(q): Coeficiente de aprendizaje para esa iteración. Es un valor mayor a 0 y menor que 1, que va disminuyendo a medida que aumente la cantidad de iteraciones. Usualmente se utilizan las fómulas: a(q) = 1/q ó a(q) = a0 * (1 – q/MAX_ITERACIONES) a0 = 0.2 ó 0.1 5) El proceso debe repetirse (una nueva iteración), volviendo a presentar todo el juego de patrones de aprendizaje (el conjunto O de objetos) hasta obtener la salida deseada. En general lo que hace una red de Kohonen es realizar una tarea de clasificación, puesto que la neurona de salida activada ante una entrada, representa la clase a la que pertenece dicha información de entrada, además ante otra entrada parecida se activa la misma neurona de salida, u otra cercana a la anterior debido a la semejanza entre las clases, así se garantiza que las neuronas topológicamente próximas sean sensibles a entradas físicamente similares; por esta causa la red es especialmente útil para establecer relaciones, previamente desconocidas, entre conjuntos de datos

REFERENCIAS

[1] J. Nilsson, Inteligencia artificial :una nueva síntesis. Madrid : McGraw-Hill Interamericana, 2001. [2] G. Pajares, Gonzalo, y M. Santos Peñas, Matilde. Inteligencia Artificial e Ingeniería del Conocimiento. Madrid: AlfaOmega. 2006. [3] J. Palma, R. Marín. Inteligencia artificial: métodos, técnicas y aplicaciones. Madrid : McGraw-Hill Interamericana. 2008. [4] P. Sell. Sistemas expertos para principiantes. México : Grupo Noriega Editores, 1993. [5] J. Giarratano. Sistemas expertos :principios y programación. México, D.F. : International Thomson. 2001. [6] W. Pratt , M. Zelkowitz. Lenguajes de programación: diseño e implementación. México. Prentice Hall Hispanoamericana, 1998. [7] C. Pérez y D. Santín. Minería de datos : técnicas y herramientas. México, D.F. Thomson. 2007. [8] J. Kennedy y A. Neville. Estadística para Ciencias e Ingeniería. México. Harla S.a. De C.v. 1982. [9] P. Isasi, y I. Galván. Redes Neuronales Artificiales: Un enfoque práctico. Madrid: Prentice Hall. 2004.

Date post:	28-Mar-2016
Category:	Documents
Upload:	facultad-de-ingenieria-usat
View:	219 times
Download:	0 times

Inteligencia Artificial

Documents