PONTIFICIA UNIVERSIDAD CATÓLICA DE VALPARAÍSO FACULTAD DE INGENIERÍA

ESCUELA DE INGENIERÍA INFORMÁTICA

Sistema Multiagentes para el problema Job Shop

Iván Alejandro Moya Quilodrán

INFORME FINAL DE PROYECTO PARA OPTAR AL TITULO PROFESIONAL DE INGENIERÍA DE EJECUCIÓN EN INFORMATICA

NOVIEMBRE 2015

PONTIFICIA UNIVERSIDAD CATÓLICA DE VALPARAÍSO FACULTAD DE INGENIERÍA

ESCUELA DE INGENIERÍA INFORMÁTICA

Sistema Multiagentes para el problema Job Shop

Profesor Guía: Claudio Cubillos Figueroa

Carrera: Ingeniería de Ejecución en Informática

NOVIEMBRE 2015

i

Dedicatoria Dedico este proyecto de título a lo más importante que tengo que en mi vida, mi familia.

Que siempre estuvieron conmigo, en las buenas y en las malas, dándome ánimo y apoyándome en todo momento.

A mis padres que, gracias a ellos soy o que soy y también sé que sin ellos no estaría donde estoy.

A mis abuelos que desde la distancia me apoyaban y rezaban para que me fuera bien y siempre los sentí conmigo.

A mis profesores que me dieron las herramientas necesarias para poder ser un buen profesional y una mejor persona, y además que siempre estaban ahí para ayudarme y enseñarme si algo no entendía o necesitaba ayuda.

A mi profesor guía que siempre confió en mí, incluso en los momentos que pero estaba académicamente hablando, ya que siempre me decía como tenía que hacer las cosas para que me fuera bien y obtener el éxito.

Para ellos es esta dedicatoria de tesis, pues es a ellos a quienes se las debo por su apoyo incondicional.

i

Índice Resumen ............................................................................................................................ iv

Lista de Figuras .................................................................................................................. v

1 Descripción del tema ................................................................................................. 1

1.1 Introducción ....................................................................................................... 1

1.2 Definición de objetivos ...................................................................................... 2

1.2.1 Objetivo general ............................................................................................. 2

1.2.2 Objetivos específicos...................................................................................... 2

1.3 Planificación primera etapa................................................................................ 3

1.4 Metodología De Trabajo .................................................................................... 3

1.4.1 Proceso Unificado Ágil .................................................................................. 4

1.4.2 Proceso Unificado Ágil Propio ...................................................................... 4

1.5 Estructura del Documento ................................................................................. 4

2 Marco de trabajo........................................................................................................ 6

2.1 Agentes Inteligentes y sistemas multiagentes .................................................... 6

2.1.1 Definición de agente....................................................................................... 6

2.1.2 Agentes Inteligentes ....................................................................................... 6

2.1.3 Sistemas Multiagentes .................................................................................... 7

2.1.4 Comunicación de los Agentes ........................................................................ 7

2.1.5 Plataforma Multiagente: JADE ...................................................................... 7

2.1.6 Metodología de Desarrollo de Agentes: PASSI ............................................. 7

2.2 NetBeans ............................................................................................................ 8

2.3 Java .................................................................................................................... 8

2.4 Algoritmo Genético ........................................................................................... 8

3 Definición del problema .......................................................................................... 10

3.1 Job Shop ........................................................................................................... 10

3.2 Solución del problema ..................................................................................... 10

3.2.1 Definición Job Shop ..................................................................................... 10

3.2.2 Formulación Matemática.............................................................................. 11

3.3 Arquitectura MAS JOB SHOP ........................................................................ 12

3.3.1 Agente Orden ............................................................................................... 12

3.3.2 Agente Máquina ........................................................................................... 12

3.3.3 Agente Stock ................................................................................................ 12

3.3.4 Movimiento de Stock ................................................................................... 13

ii

3.4 Diseño de la Arquitectura Propuesta ............................................................... 13

3.5 Algoritmo de Planificación .............................................................................. 14

3.5.1 Algoritmo Genético ...................................................................................... 14

3.6 Diseño De La Interfaz (GUI) ........................................................................... 18

4 Desarrollo del proyecto ........................................................................................... 19

4.1 Presentación del caso de estudio ...................................................................... 19

4.2 Desarrollo del caso de estudio ......................................................................... 19

4.3 Modelo Sistema multiagente para Job Shop .................................................... 19

4.3.1 Modelo de Requerimiento del sistema ......................................................... 19

4.3.2 Diagrama de identificación de Roles ........................................................... 21

4.3.3 Especificación de Tareas .............................................................................. 21

4.3.4 Modelo de Sociedad de Agentes .................................................................. 21

4.3.5 Modelo de Implementación de Agentes ....................................................... 21

4.4 Implementación Algoritmo Genético para Job Shop ....................................... 21

4.4.1 Representación ............................................................................................. 21

4.4.2 Función de Evaluación ................................................................................. 23

4.4.3 Generación de Población Inicial .................................................................. 23

4.4.4 Selección ...................................................................................................... 23

4.4.5 Cruzamiento ................................................................................................. 24

4.4.6 Mutación....................................................................................................... 24

4.4.7 Sustitución .................................................................................................... 25

4.4.8 Criterios de Término .................................................................................... 25

5 Implementación y pruebas ...................................................................................... 26

5.1 Implementación del sistema ............................................................................. 26

5.1.1 Obtención de los datos ................................................................................. 26

5.1.2 Arquitectura Gui ........................................................................................... 27

5.2 Pruebas ............................................................................................................. 28

5.2.1 Instancias de Job Shop ................................................................................. 28

5.2.2 Resúmenes de Pruebas de Prototipos ........................................................... 29

6 Conclusión ............................................................................................................... 31

Referencias ....................................................................................................................... 32

Anexos ............................................................................................................................... 1

A: Diagrama de Descripción de Dominio (DD) ............................................................ 1

B: Diagrama de identificación de agentes ...................................................................... 2

iii

C: Representación Cruzamiento ......................................................................................... 3

D: Diagrama de identificación de roles: Ejecutar planeación de JobShop ........................ 4

E: Diagrama de identificación de roles: Inicio ................................................................... 5

F: Especificación de Tareas: Agente inicio ........................................................................ 6

G: Especificación de tareas: Agente Orden ....................................................................... 7

H: Especificación de tareas: Agente Planificación ............................................................ 8

I: Descripción de la ontología de dominio ......................................................................... 9

J: Diagrama de Implementación de Agente ..................................................................... 10

K: Capturas de pantalla .................................................................................................... 11

iv

Resumen El presente trabajo consiste en el desarrollo de un sistema multiagente que soluciona y

visualiza, de una manera más entendible, el problema de planificación Job Shop. El programa mencionado utiliza la tecnología multiagente para la comunicación de los diferentes datos. Además se utiliza, dentro de los agentes un algoritmo genético para que se logre una solución que se acerque al óptimo.

Para cumplir el objetivo es utilizada la tecnología multiagente en un entorno Java, utilizando la plataforma JADE. Para la integración del programa con una visualización más amigable se utilizó Java en la plataforma NetBeans.

El fin del proyecto consiste en que el usuario pueda comprender y visualizar de mejor manera, así permitirá al usuario analizar y monitorear de mejor manera el trabajo realizado por el software.

Palabras-claves: Job Shop, Interfaz, Tecnología multiagente, Java, JADE, Algoritmo Genético.

Abstract This work involves the development of a multi-agent system that solves and displays, in

a more understandable, the Job Shop scheduling problem. The above program uses multi-agent technology for communication of different data. Moreover, within the agents used a genetic algorthim for a solution that approaches the optimum is achieved.

To meet the target multi-agent technology is used in a Java environment, using the JADE platform. Java is used for integration of the program with a more friendly display on the NetBeans platform.

The project goal is to enable the user to understand and visualize better, and allow the user to analyze and better monitor the work done by the software.

Key words: Job Shop, interface, multi-agent technology, Java, JADE, Genetic Algorithm.

v

Lista de Figuras

Figura 1 Carta Gantt ........................................................................................................... 3 Figura 2 Selection and Recombination ............................................................................ 15 Figura 3 Diagrama de identificación de agente................................................................ 20 Figura 4 Ejemplo de un problema de tres jobs y tres máquinas....................................... 22 Figura 5 Operaciones de los jobs y correspondencia con las máquinas .......................... 23 Figura 6 Orden de procesamiento de los jobs sobre la máquina 1 ................................... 23 Figura 7 Obtención datos ................................................................................................. 26 Figura 8 Obtención de tareas............................................................................................ 27 Figura 9 Programa principal............................................................................................. 28 Figura 10 Diagrama de descripción de dominio ................................................................ 1 Figura 11 Identificación de Agentes .................................................................................. 2 Figura 12 Operador genético de cruzamiento de un punto ................................................ 3 Figura 13 Operador genético de cruzamiento de dos puntos ............................................. 3 Figura 14 Operador genético de cruzamiento multipunto ................................................. 3 Figura 15 Operador genético de cruzamiento uniforme .................................................... 3 Figura 16 Diagrama de identificación de roles: Ejecutar planeación de Job Shop ............ 4 Figura 17 Diagrama de identificación de roles: Inicio ....................................................... 5 Figura 18 Especificación de Tareas: Agente inicio............................................................ 6 Figura 19 Especificación de tareas: Agente Orden ............................................................ 7 Figura 20 Especificación de tareas: Agente Planificación ................................................. 8 Figura 21 Descripción de la ontología de dominio ............................................................ 9 Figura 22 Diagrama de Implementación de Agente ........................................................ 10 Figura 23 inicio interfaz ................................................................................................... 11 Figura 24 Cargando Planificación .................................................................................... 11 Figura 25 Gráfico Planificación ....................................................................................... 12 Figura 26 Gráfico Job....................................................................................................... 12 Figura 27 Generar Reporte ............................................................................................... 13 Figura 28 Reporte en pdf.................................................................................................. 13

1

1 Descripción del tema

1.1 Introducción

El término planificación fue presentada inicialmente en el ámbito de las industrias. Pero en esta estructura caben muchos problemas de planificación del mundo real que se pueden presentar en el negocio, la computación, el gobierno, los servicios sociales y otros más [1].

En estos tiempos y sobretodo en Europa, la mano de obra en industrias es de elevado costo, es que en la actualidad la industria se está enfocando en los métodos que solucionen rápidamente los problemas de planificación, para que con ellos se pueda disminuir los tiempos de ocio y porque estos problemas desafían los métodos ya existentes de búsqueda

El Job Shop es uno de los problemas más conocidos de planificación en las industrias. Éste consiste en que existe n trabajos, cada uno de los cuales debe ser procesado exactamente una vez en cada una de las m máquinas para terminar el trabajo. Todas estas tareas se deben hacer de forma tal, que casi no exista tiempo de ocio y reducir los costos de producción. Ya existen programas que solucionan este problema con ayuda de sistemas multiagentes. Es este proyecto se seleccionará un software con el objetivo de desarrollar interfaz más amigable al usuario para que pueda entender de una mejor manera la solución y los tiempos en que se ejecutaran las tareas y los tiempos de ocio (tiempo de espera). El software se encarga de manera óptima de planificar las órdenes de trabajos que van llegando para minimizar casi al máximo los tiempos de espera y maximizar el proceso de las órdenes.

Para lograr una mejor optimización se utilizará el algoritmo genético, el cual es una heurística de optimización y que gracias al azar se puede lograr mejoras en la solución

Se utilizará un entorno JAVA, donde a través de agentes se realizará la integración des sistema existente integrado en JADE y la interfaz también será realizada en JAVA.

2

1.2 Definición de objetivos

1.2.1 Objetivo general

Obtener una solución lo más óptima posible y representarla de una forma más amigable al usuario para su mejor entendimiento.

1.2.2 Objetivos específicos

Estudiar en que consiste Job Shop y el funcionamiento del Sistema multiagente que se utiliza para resolverlo.

Investigar la forma de representar la planificación hecha por el sistema multiagente.

Realizar y comunicar la interfaz con el sistema multiagente. Realizar las respectivas pruebas del sistema.

3

1.3 Planificación primera etapa

Figura 1 Carta Gantt

1.4 Metodología De Trabajo El Proceso Unificado no es simplemente un proceso, sino un marco de trabajo extensible

que puede ser adaptado a organizaciones o proyectos específicos. El Proceso Unificado de

4

Rational se caracteriza por estar dirigido por casos de uso, centrado en la arquitectura y por ser iterativo e incremental [29].

1.4.1 Proceso Unificado Ágil

Es una versión simplificada del Proceso Unificado de Rational (RUP) [30]. Este describe de una manera simple y fácil de entender la forma de desarrollar aplicaciones de software de negocio usando técnicas ágiles y conceptos que aún se mantienen válidos en RUP. El Ágil UP aplica técnicas ágiles incluyendo Desarrollo Dirigido por Pruebas. Esta será la metodología que se utilizará en el proyecto [31].

1.4.2 Proceso Unificado Ágil Propio

El desarrollo de este proyecto lo componen 5 fases, la fase de inicio consta de la definición del problema y de que trata el proyecto, ya sea su objetivo principal como específicos. En la fase de elaboración se realiza la planificación del proyecto (carta Gantt), exponer las tecnologías de trabajo a utilizar y el marco teórico del proyecto. En la fase de construcción se comienza a realizar el proyecto, comenzando con un pequeño prototipo para luego ir realizando nuevas iteraciones y pruebas. Las iteraciones consisten en ir agregando nuevas funcionalidades como también ir mejorando la interfaz. A continuación se describen las iteraciones principales:

1. Se comenzara con una simple interfaz, en la cual se mostraran los tiempos y procesos en que las ordenes y las máquinas trabajaran.

2. Luego se cambiaran los tiempos por porcentaje de progreso, representando las órdenes de trabajo con colores para su mejor entendimiento.

3. Después agregar los menús desplegables dentro de la interfaz y agregar los eventos (opciones) que pueden ocurrir en la ejecución, representando cuando una orden es cancelada o tiene algún retraso, y la realización de una nueva orden, entre otros eventos.

4. Por ultimo agregar las texturas a los modelos y crear u entorno amigable.

Para terminar la fase final que corresponde a la fase de pruebas, donde se realizaran las pruebas correspondientes al software final.

1.5 Estructura del Documento En este apartado se dará a conocer los diversos capítulos que contiene este informe y de

que trata cada uno con una breve descripción. Cada capítulo se refiere a una temática diferente, pero siempre centrado en el trabajo que se quiere realizar. Los capítulos son:

Capítulo 1 Descripción del tema: Este capítulo explica de que trata el proyecto, su objetivo principal y objetivos específicos.

Capítulo 2 Marco de trabajo: en este capítulo se presentan las tecnologías que se utilizaran para desarrollar el proyecto. En primer lugar se refiere a la tecnología multiagente, plataformas que se utilizará y por último el lenguaje de programación.

5

Capítulo 3 Definición del problema: este capítulo se centra en el problema de Job Shop, con sus restricciones, fórmula matemática, algoritmos que lo resuelven y como se lleva a cabo en los proyectos anteriores, que hace referencia este informe. Además se centra en la solución propuesta por Leonardo Espinoza con los diagramas principales de la solución que él diseño.

Capítulo 4 Desarrollo del Proyecto: en este capítulo se presentan las modificaciones que se hicieron para el funcionamiento del problema. Se presenta la identificación de los agentes, identificación de roles, implementación de agentes y como los agentes entre sí.

Capítulo 5 Implementación y pruebas: en este capítulo se presentan las pruebas que se realizaron al sistema y su comparación con otro sistema similar.

Conclusiones: Por último se encuentra las conclusiones, donde se realiza una comprensión general de los conceptos vistos anteriormente.

6

2 Marco de trabajo En este capítulo se resumen las tecnologías utilizadas para el desarrollo de este proyecto.

Las tecnologías utilizadas son: Agentes Inteligentes y Sistemas Multiagentes, NetBeans y Java.

2.1 Agentes Inteligentes y sistemas multiagentes

A continuación se definirá en forma breve en que consiste la tecnología de agentes y sistemas multiagentes utilizada para la realización del proyecto.

2.1.1 Definición de agente

Existen variadas definiciones para el concepto de agente, algunas de estas son: “Un agente es cualquier cosa que pueda ver en su entorno a través de sensores y actuar en su entorno a través de efectores” [4], en esta definición describe una de las características de un agente computacional que es poder percibir y actuar en un entorno determinado.

Otra definición de agente es la propuesta por FIPA (Foundation for Intelligent Physical Agents): “Un agente es una entidad de software encapsulado con su propio estado, conducta, hilo de control y la habilidad para interactuar y comunicarse con otras entidades (gente, otros agentes o sistemas legados)”, en esta definición se destaca la capacidad de un agente que no solo se comunica con el medio en el cual se encuentra, sino que también con otros agentes del sistemas y entidades externas como usuarios.

Entre otras definiciones también se encuentra: “Un agente es un sistema computacional que está situado en algún ambiente, y que es capaz de actuar autónomamente en dicho ambiente con el fin de cumplir sus objetivos” [5], donde se destaca que un agente posee autonomía, y es capaz de cumplir sus objetivos por sus propios medios.

2.1.2 Agentes Inteligentes

Para que un agente sea inteligente debe cumplir con ciertas características, las cuales son:

Autonomía: Un agente a partir de sus propios conocimientos debe ser capaz de alcanzar sus objetivos, sin necesidad que un usuario le guíe.

Sociabilidad: Los Agentes son capaces de comunicarse entre sí (Sistema Multiagente) y colaborar entre ellos para lograr un objetivo en común, como también interactuar con entidades externas al propio sistema, como es el caso del usuario.

Reactividad: Un agente debe ser capaz de percibir estímulos, tanto de su ambiente como del mundo externo, estos estímulos afectan las acciones realizadas por el agente para alcanzar sus objetivos.

Pro-actividad: Un agente no solo actúa en función de los estímulos, sino que puede realizar acciones como resultado de sus propias decisiones.

7

Aquellos agentes que posean estos atributos: autonomía, sociabilidad, reactividad y pro-actividad se clasifican en la noción débil de agente. Un agente es inteligente si es racional, coherente y adaptable, en mayor o menor medida. Un agente será más inteligente cuánto más desarrolladas tenga estas características de inteligencia, racionalidad, coherencia y adaptación [6].

2.1.3 Sistemas Multiagentes

Una de las definiciones de Sistema Multiagente es: “Un sistema multiagente es una red de problem-solvers que trabajan conjuntamente para encontrar respuestas a problemas que ven más allá de las capacidades o conocimiento individuales de cada entidad” [7].

En general los sistemas multiagentes son una sociedad de agentes que por medio de la interacción y colaboración entre los agentes se llega a una solución del problema. El éxito de la interacción de los agentes requiere que cada uno de estos tenga la capacidad de cooperar, coordinar y negociar con los demás agentes como también con los usuarios del sistema [8].

2.1.4 Comunicación de los Agentes

Para que los agentes puedan colaborar entre ellos necesitan un lenguaje de comunicación. FIPA ACL es uno lenguaje que está asociado con la arquitectura abierta de FIPA, el cual se basa en los actos de habla. Al igual que KQML, posee una sintaxis similar y está diseñado para trabajar con cualquier lenguaje y especificación de ontología. La diferencia de FIPA ACL con KQML es que poseen un grupo de performatives distintos [9].

2.1.5 Plataforma Multiagente: JADE

JADE (Java Agent Development Environment) es una plataforma de software completamente implementada en Java. Esta plataforma facilita el desarrollo de Sistemas Multiagente a través de un framework que cumple con las especificaciones FIPA y una serie de herramientas gráficas para administrar y monitorear la ejecución de los agentes. El objetivo de JADE es simplificar el desarrollo de agentes y a su vez garantizar el cumplimiento del estándar FIPA[10].

2.1.6 Metodología de Desarrollo de Agentes: PASSI

PASSI (Process of Agent Societies Specification and Implementation) es una metodología paso a paso para el diseño y desarrollo de sistemas Multiagentes. PASSI integra los modelos de diseño y conceptos de la Ingeniería de Software Orientada a Objetos y los enfoques de la Inteligencia Artificial. Se utiliza UML como lenguaje de modelado, principalmente por su amplia aceptación y capacidad de extensión. El proceso de diseño de PASSI se compone de cinco modelos, los cuales pueden ser divididos en fases de construcción de Sistemas Multiagente [11].

8

2.2 NetBeans NetBeans es un entorno de desarrollo integrado libre, hecho principalmente para el

lenguaje de programación Java. Existe además un número importante de módulos para extenderlo. NetBeans IDE es un producto libre y gratuito sin restricciones de uso.

Esta plataforma permite que las aplicaciones sean desarrolladas a partir de un conjunto de componentes de software llamados módulos. Un módulo es un archivo Java que contiene clases de java escritas para interactuar con las APIs de NetBeans y un archivo especial (manifest file) que lo identifica como módulo. Las aplicaciones construidas a partir de módulos pueden ser extendidas agregándole nuevos módulos. Debido a que los módulos pueden ser desarrollados independientemente, las aplicaciones basadas en la plataforma NetBeans pueden ser extendidas fácilmente por otros desarrolladores de software.

El NetBeans IDE es un IDE de código abierto escrito completamente en Java usando la plataforma NetBeans. El NetBeans IDE soporta el desarrollo de todos los tipos de aplicación Java (J2SE, web, EJB y aplicaciones móviles). Entre sus características se encuentra un sistema de proyectos basado en Ant, control de versiones y refactoring.

2.3 Java Java es un lenguaje de programación de propósito general, concurrente, orientado a

objetos y basado en clases que fue diseñado específicamente para tener tan pocas dependencias de implementación como fuera posible. Su intención es permitir que los desarrolladores de aplicaciones escriban el programa una vez y lo ejecuten en cualquier dispositivo (conocido en inglés como WORA, o "write once, run anywhere"), lo que quiere decir que el código que es ejecutado en una plataforma no tiene que ser recompilado para correr en otra. Java es, a partir de 2012, uno de los lenguajes de programación más populares en uso, particularmente para aplicaciones de cliente-servidor de web, con unos 10 millones de usuarios reportados.

2.4 Algoritmo Genético

Holland propuso los algoritmos genéticos en los comienzos de la década de 1970 como programas que imitan procesos evolutivos en la naturaleza [32]. Los algoritmos genéticos manipulan una población de potenciales soluciones para un problema de optimización. Específicamente, estos operan sobre representaciones codificadas de las soluciones, equivalente al material genético de los individuos en la naturaleza, no sobre las soluciones mismas. El algoritmo genético de Holland codifica las soluciones como una cadena de bits provenientes de un alfabeto binario. Tal como ocurre en la naturaleza, la selección provee del mecanismo de conducción necesaria para que las mejores soluciones sobrevivan. Cada solución es asociada a un valor de aptitud que refleja que tan buena es, en comparación a otras soluciones en la población. Mientras más grande sea el valor de aptitud de un individuo, más grande será la probabilidad de supervivencia y reproducción, y más grande será su representación en la generación subsiguiente. La recombinación del material genético en un algoritmo genético es simulada a través de un mecanismo de cruza que intercambia porciones entre cadenas. Otra operación, llamada mutación, causa alteraciones aleatorias y esporádicas

9

de los bits de la cadena. La mutación también tiene una analogía directa en la naturaleza y toma el rol de regenerar material genético perdido y crear material nuevo.

10

3 Definición del problema El problema consiste en desarrollar un Sistema multiagente que de la solución al

problema de planificación llamado Job Shop, y al mismo tiempo poder mostrar al usuario de una forma más amigable cómo será la ejecutada, en tiempos, la ejecución de los resultados. Además, la planificación se hará con algoritmo genético que también se definirá en este capitulo

El objetivo principal del proyecto es poder representar la planificación del Job Shop y lograr un resultado más óptimo logrado por Leonardo, y además dar información relevante de los tiempos de ejecución y tiempos de ocio de las máquinas y de las órdenes de trabajo, mostrando información gráfica para su entendimiento.

En este capítulo se dará a conocer información sobre Job Shop, Proyecto multiagentes para Job Shop realizado por Leonardo y Algoritmo Genético [33] con la cual se cumplirán los objetivos dichos anteriormente

3.1 Job Shop

Job Shop es un problema de optimización combinatoria (planificación) se encuentran contenidos en la clase NPhard o problemas en los que el tiempo de cómputo necesario para resolverlos crece desproporcionadamente conforme aumenta el tamaño del problema. La función de la planificación es la asignación de recursos limitados a tareas a lo largo del tiempo y tiene como finalidad la optimización de uno o más objetivos. Los recursos pueden ser máquinas en un taller, ladrillos en una construcción, unidades de procesamiento en un ambiente computacional, etc. Como tareas se pueden tener operaciones de un proceso de producción, etapas de un proyecto de ingeniería, ejecuciones de un programa computacional, etc. Cada tarea puede tener diferentes niveles de prioridad, así como tiempos de posibles inicios. Los objetivos pueden tomar varias formas: minimizar los tiempos de finalización de la última tarea, minimizar el número de tareas luego de una fecha de entrega acordada, etc.

3.2 Solución del problema

En este proyecto se tomará el trabajo realizado Leonardo Espinoza Vera, en el cual se harán cambios para poder hacer una solución más óptima con un algoritmo genético. Es por ello que a continuación se demostrará la solución al problema de Job Shop dinámico propuesta en su trabajo [25].

3.2.1 Definición Job Shop

En el problema de planificación de Job-shop de n m , existen n trabajos, cada uno de los cuales debe ser procesado exactamente una vez en cada una de las m maquinas. Cada trabajo i sigue una secuencia a través de m maquinas en un orden predefinido i , donde i ( j)

denota la j -esima maquina en la secuencia, como se ve 1 i n y 1 j m . El procesado del trabajo i en la maquina i ( j) es denotado por o ij y es llamado operación. Una operación o ij es procesada en la maquina i (j) i por una duración entera ij 0 . Para 2 j m, o ij no

11

puede iniciar su procesamiento hasta que oij 1 no haya terminado. Las restricciones impuestas por las secuencias de procesamiento de cada trabajo son llamadas restricciones de precedencia y las impuestas por las unidades de capacidad son llamadas restricciones de recursos.

Cada solución s de una instancia de JSSP de n x m especifica un orden de procesado para todos los trabajos sobre cada máquina. Existen n! posibles órdenes de procesamiento para cada máquina, resultando en posibles soluciones a , entre las cuales se encuentran muchas soluciones que no son factibles, por no cumplir con las restricciones de precedencia o por crear dependencias cíclicas. El conjunto de soluciones factibles de una instancia se denota por S .

Cada solución s S especifica de manera implícita el tiempo más temprano de inicio (est ij ) para cada operación o ij tal que todas las restricciones de precedencia y recursos son satisfechas. El tiempo más temprano de completado est ij es dado entonces por

. El makespan C max s de una solución s S es el máximo tiempo más temprano de completado de la última operación de cualquier trabajo i, esto es

. El makespan optimo denotado por , es igual al mínimo makespan entre las soluciones factibles, esto es [26].

3.2.2 Formulación Matemática

Es reconocido por muchos investigadores que los problemas de planificación pueden ser resueltos de manera óptima usando técnicas de programación matemática; y la formulación matemática más común para el JSSP es la programación lineal entera mixta, propuesta por Alan Manne en el año 1960. Se compone de un conjunto de restricciones lineales y una función objetivo lineal, pero con la restricción adicional que algunas de las variables de decisión son enteras. En el modelo las variables enteras son binarias y se utilizan para implementar las restricciones disyuntivas. K corresponde a un valor arbitrario grande que ha sido indicado que debe ser mayor que la suma de los tiempos de procesamiento de todas la operaciones menos el tiempo de procesamiento más pequeño.

Minimizar Sujeto a: Tiempos de inicio Restricción de Precedencia: si precede a

Restricción Disyuntiva: si precede a , en otro caso Donde

Dónde: : Tiempo de inicio de cada operación. J: Conjunto de n trabajos a ser procesados.

12

M: Conjunto de m recursos o maquinas. : Operación del trabajo que debe ser procesado en la maquina por un periodo

ininterrumpido de tiempo .

A pesar de la elegancia conceptual, el número de variables enteras crece exponencialmente e incluso si se utilizan formulaciones más compactas estas siguen requiriendo un gran número de restricciones. Como resultado las técnicas de programación matemática son capaces de resolver instancias altamente simplificadas, dentro de un tiempo razonable, de modo que no resulta sorprendente que técnicas adecuadas para JSSP, encuentren en otras áreas de investigación [27].

3.3 Arquitectura MAS JOB SHOP

Las siguientes funciones fueron desarrolladas por Leonardo Espinoza en las que utilizaron para resolver el problema de la parte lógica.[25]:

Orden de producción desde el cliente: Agente Orden. Centro de producción: Agente Máquina. Stock de materiales: Agente Stock. Operación: interacción de elementos entre el Agente Orden y el Agente Máquina. Movimiento de stock: interacción de elementos entre Agente Stock y el Sistema de

Abastecimiento.

3.3.1 Agente Orden

Representa una orden de producción que se introdujo en el sistema de planificación. Esa orden es capturada por el Agente Cliente, el que representa a los demandantes de órdenes de producción. Es creado cuando una orden de nuevo puesto es introducida y funciona con la colocación de todas sus operaciones en centros, respetando lo más tempranero y el último rango de tiempo de principio. La información necesaria para un agente de orden es: La fecha tope de producción, la prioridad del cliente, el set de “Operationes” que componen el proceso. [25]

3.3.2 Agente Máquina

Representa las máquinas o centros de producción y surte efecto para ubicar el tiempo de principio de ejecución de todo operaciones demandadas de fuera se sobrecarga. Cada agente central se mantiene: (i) las planeadas operaciones en la máquina, (ii) los lugares libres disponibles a ser ocupada por operaciones, (iii) la actual temperatura de Simulated Annealing. [25]

3.3.3 Agente Stock

Los agentes stock manejan materiales manteniendo el nivel mínimo de stock. El comportamiento de los agentes stock genera el plan de movimiento de stock incluyendo: La orden de compra y el plan de movimiento de stock para suministro de operación. [25]

13

3.3.4 Movimiento de Stock

Hay dos tipos de movimientos de stock: La entrada de materiales (debido a la entrega de proveedores) y el material que egresa (suministrar a la producción). “El tipo de movimiento” se usa para modelar estos aspectos con la información: El identificador de movimiento, fecha de movimiento de stock, cantidad, cantidad de acciones después del movimiento. [25]

3.4 Diseño de la Arquitectura Propuesta La arquitectura que tiene el trabajo de Leonardo Espinoza será de gran ayuda para

nuestro trabajo, ya que se encuentran bien definidos las características que hace cada agente, su funcionalidad y como se comunican Anexo B Diagrama de identificación de agentes. Sin embargo se implementara 2 agentes más:

a) Agente planificado: Este agente será el nexo entre el Agente Orden, el Agente Máquina y el agente Inicio. Éste tendrá la funcionalidad de hacer una planificación y comprobar su óptimo haciendo iteraciones y comprobando que cumpla con las restricciones que presenta el Job Shop:

No puede haber 2 o más máquinas ejecutando la misma orden de trabajo en el mismo tiempo.

Una orden de trabajo tiene que pasar por todas las máquinas para que esta sea puesta como completa.

Buscar la mejor solución para el problema.

b) Agente Inicio: Este agente será el iniciador del programa. Su funcionalidad es crear a los agentes que interactúan con la planificación de Job Shop y también con el usuario. Éste estará atento de cualquier evento que el usuario, como por ejemplo la visualización de la planificación, pausa y stop de esta misma.

Estos agentes se insertan en el modelo propuesto por Leonardo Espinoza, sin embargo se redefinirán ya que no se ocuparan de la misma forma. En la figura 18 del Anexo B, Diseño de propuesta, se muestra la arquitectura del proyecto. A continuación se describen los agentes que se desarrollan en el sistema multiagente para solucionar el Job Shop.

Es importante destacar que los nombres de los agentes mencionados en la figura 3 sólo son una referencia y no son necesariamente los verdaderos nombres de los agentes. A continuación se describe cada uno de ellos con sus nombres respectivos.

Agente Orden: Es el responsable de obtener todas las ordenes de los clientes reales, ya sean ordenes de trabajo, cancelaciones, etc. Como también informa acerca del estado de la orden y eventos que puedan ocurrir al cliente real.

Agente Máquina: Es el encargado de brindar toda la información de la asignación de tareas, situación, cambios, etc. También se encarga de informar el estado de la orden como también acerca de su progreso durante el periodo de tiempo.

14

Agente Cliente: Es el responsable de la comunicación entre el agente Orden y el agente Planificador. Este agente genera las órdenes con sus respectivas tareas.

Agente Stock: Es responsable de la comunicación del agente Máquina y el agente Planificador. Éste debe negociar los materiales que necesita el agente Máquina con el agente Tarea.

3.5 Algoritmo de Planificación

El proyecto de Leonardo Espinoza originó una solución para el problema del Job Shop, el cual será basé para este proyecto, sin embargo se realizaron algunas modificación a heurísticas que propuso, ya que no se lograba obtener un buen óptimo. A continuación se dará a conocer el concepto de algoritmo genético, su definición y cuáles son los requerimiento mínimos que necesita para funcionar.

3.5.1 Algoritmo Genético

Para acercarse al óptimo se utilizará un algoritmo genético evolutivo. Este algoritmo fue propuesto por Holland en los comienzos de la década de 1970 como programas que imitan procesos evolutivos en la naturaleza [32]. Los algoritmos genéticos manipulan una población de potenciales soluciones para un problema de optimización. Específicamente, estos operan sobre representaciones codificadas de las soluciones, equivalente al material genético de los individuos en la naturaleza, no sobre las soluciones mismas. El algoritmo genético de Holland codifica las soluciones como una cadena de bits provenientes de un alfabeto binario. Tal como ocurre en la naturaleza, la selección provee del mecanismo de conducción necesaria para que las mejores soluciones sobrevivan. Cada solución es asociada a un valor de aptitud que refleja que tan buena es, en comparación a otras soluciones en la población. Mientras más grande sea el valor de aptitud de un individuo, más grande será la probabilidad de supervivencia y reproducción, y más grande será su representación en la generación subsiguiente. La recombinación del material genético en un algoritmo genético es simulada a través de un mecanismo de cruza que intercambia porciones entre cadenas. Otra operación, llamada mutación, causa alteraciones aleatorias y esporádicas de los bits de la cadena. La mutación también tiene una analogía directa en la naturaleza y toma el rol de regenerar material genético perdido y crear material nuevo.

Para el funcionamiento de un SGA es esencial una población de cadenas binarias. Cada cadena de unos y ceros es una versión codificada de una solución al problema de optimización. Usando operadores genéticos como la cruza y la mutación, el algoritmo crea generaciones subsiguientes de las cadenas de la población actual. El ciclo generacional es repetido hasta que un criterio de término se cumpla. A continuación se encuentra la estructura básica del algoritmo genético clásico, el que resume su funcionamiento, el cual contiene los siguientes componentes: una población de cadenas binarias, parámetros de control, una función de aptitud, operadores genéticos, un mecanismo de selección y un mecanismo para codificar las soluciones como cadenas binarias. [33]

15

Algoritmo genético ()

Requiere: Una instancia de un problema se scheduling P.

Produce: Una planificación H para la instancia P.

1 Generar población Inicial 2 Evaluar población 3 Mientras No se cumpla el criterio de parada Hacer 3 Seleccionar soluciones para siguiente población 5 Realizar cruzamiento y mutación 6 Evaluar población 7 Fin mientras 8 Devuelve La planificación del mejor cromosoma evaluado hasta el

momento Un Algoritmo Genético puede verse como un proceso con dos etapas. La primera inicia

con la población actual y tras un proceso de selección se genera una población intermedia, con lo que se inicia la segunda etapa en la cual se realizan sobre la población intermedia distintas operaciones de cruzamiento (o recombinación) y mutación, obteniendo de ese modo la siguiente población. Una generación es el paso desde una población a otra tras el proceso descrito. Esto puede apreciarse gráficamente en la Figura 2.

Figura 2 Selection and Recombination

3.5.1.1 Elección de la población inicial

En términos generales, la población inicial debe ser lo más variada posible. Es necesario que la distribución de aptitudes sea uniforme para evitar la convergencia prematura. En la práctica, por falta de mayor información, se elige la población inicial al azar. El conocimiento específico puede ayudar a formar una población inicial factible con algún individuo cercano al

16

óptimo. La iniciación de la población en GA se realiza por muestreos aleatorios de una variable binaria, l. pop_size veces (muestreos independientes), donde l es la longitud del cromosoma; de esta forma se determina cada bit de la población inicial P(0) en forma aleatoria.

3.5.1.2 Selección

La selección se basa en el mecanismo supervivencia de los más aptos. Las soluciones más aptas sobreviven mientras las débiles perecen. En el SGA, una cadena más apta recibe un número más elevado de descendencia y así una probabilidad más alta de sobrevivir en la siguiente generación. Se pueden describir tres mecanismos conocidos:

a) Selección elitista: Esta trata de garantiza la selección de los miembros más aptos de cada generación. La mayoría de los algoritmos geneticos no utilizan elitismo puro, sino que usan una forma modificada por la que el individuo mejor, o algunos de los mejores, son copiados hacia la siguiente generación en caso de que no surja nada mejor.

b) Selección proporcional a la aptitud: Los individuos más aptos tienen más probabilidad de ser seleccionados, pero no la certeza.

c) Selección escalada: Al incrementarse la aptitud media de la población, la fuerza de la presión selectiva también aumenta y la función de aptitud se hace más discriminadora. Este método puede ser útil para seleccionar más tarde cuando todos los individuos tengan una aptitud relativamente alta y sólo es distingan pequeñas diferencias en la aptitud.

d) Selección por torneo: Se eligen subgrupos de individuos de la población, y los miembros de cada subgrupo compiten entre ellos. Sólo se eligen a un individuo de cada subgrupo para la reproducción. Este método tiene un cierto grado de elitismo donde se elige el mejor.

e) Selección por rango: A cada individuo de la población se le asigna un rango numérico basado en su aptitud, y la selección se basa en este ranking, en lugar de las diferencias absolutas en aptitud. La ventaja de este método es que puede evitar que individuos muy aptos ganen dominancia al principio a expensas de los menos aptos, lo que reduciría la diversidad genética de la población y podría obstaculizar la búsqueda de una solución aceptable.

f) Selección generacional: La descendencia de los individuos seleccionados en cada generación se convierte en toda la siguiente generación. No se conservan individuos entre las generaciones.

g) Selección por estado estacionario: La descendencia de los individuos seleccionados en dad generación vuelven al acervo genético preexistente, reemplazando a algunos de los miembros menos aptos de la siguiente generación. Se conservan algunos individuos entre generaciones.

17

3.5.1.3 Cruzamiento

Luego de la selección viene el cruzamiento, operación crucial de un algoritmo genético. Pares de cadenas son seleccionadas aleatoriamente de la población sujeta al cruzamiento.

Existen muchas maneras de cruces en las que se destacan:

a) Cruce de un punto: Se establece un punto de intercambio en un lugar aleatorio del genoma de los dos individuos, y uno de los individuos contribuye todo su código anterior a ese punto y el otro individuo contribuye todo su código a partir de ese punto para producir una descendencia. El proceso se refleja en el anexo C Representación cruzamiento figura 12

b) Cruce de dos puntos: Se establecen dos puntos de intercambio en un lugar aleatorio del genoma de los dos individuos, y uno de los individuos contribuye todo su código anterior al primer punto y posterior al segundo punto y el otro individuo contribuye todo su código entre los puntos. El proceso se refleja en el anexo C Representación cruzamiento figura 13

c) Cruzamiento Multipunto: Como extensión al mecanismo de dos puntos, el cruzamiento multipunto, trata cada cadena o individuo como un anillo de bits dividido por k puntos de cruzar, resultado k segmentos. Un conjunto de segmentos alternados se intercambian entre los individuos a cruzar. Este proceso se ilustra en el anexo C Representación cruzamiento figura 14

d) Cruce Uniforme: Cada gen de la descendencia tiene las mismas probabilidades de pertenecer a uno u otro padre. El proceso se ilustra en anexo C Representación cruzamiento figura 15

3.5.1.4 Mecanismo de Mutación

La mutación de un individuo provoca que alguno de sus genes, generalmente uno sólo, varíe su valor de forma aleatoria.

Aunque se pueden seleccionar los individuos directamente de la población actual y mutarlos antes de introducirlos en la nueva población, la mutación se suele utilizar de manera conjunta con el operador de cruce. Primeramente se seleccionan dos individuos de la población para realizar el cruce. Si el cruce tiene éxito entonces uno de los descendientes, o ambos, se muta con cierta probabilidad Pm. Se imita de esta manera el comportamiento que se da en la naturaleza, pues cuando se genera la descendencia siempre se produce algún tipo de error, por lo general sin mayor trascendencia, en el paso de la carga genética de padres a hijos.

La probabilidad de mutación es muy baja, generalmente menor al 1%. Esto se debe sobre todo a que los individuos suelen tener un ajuste menor después de mutados. Sin embargo se realizan mutaciones para garantizar que ningún punto del espacio de búsqueda tenga una probabilidad nula de ser examinado.

Tal y como se ha comentado, la mutación más usual es el reemplazo aleatorio. Este consiste en variar aleatoriamente un gen de un cromosoma. Si se trabaja con codificaciones binarias consistirá simplemente en negar un bit. También es posible realizar la mutación intercambiando los valores de dos alelos del cromosoma. Con otro tipo de codificaciones no binarias existen otras opciones:

18

a) Incrementar o decrementar a un gen una pequeña cantidad generada aleatoriamente. b) Multiplicar un gen por un valor aleatorio próximo a 1.

3.5.1.5 Sustitución (Reemplazo)

Cuando se trabaja con una única población, sobre la que se realizan las selecciones e inserciones, deberá tenerse en cuenta que para insertar un nuevo individuo deberá de eliminarse previamente otro de la población. Existen diferentes métodos de reemplazo:

a) Aleatorio: El nuevo individuo se inserta en un lugar cualquiera de la población. b) Reemplazo de padres: Se obtiene espacio para la nueva descendencia liberando el

espacio ocupado por los padres. c) Reemplazo de similares: Una vez obtenido el ajuste de la descendencia se

selecciona un grupo de individuos (entre seis y diez) de la población con un ajuste similar. Se reemplazan aleatoriamente los que sean necesarios.

d) Reemplazo de los peores: De entre un porcentaje de los peores individuos de la población se seleccionan aleatoriamente los necesarios para dejar sitio a la descendencia.

3.5.1.6 Criterio de Término

Para terminar la ejecución de un SGA, se debe especificar un criterio de término. Se puede especificar que termine luego de pasado cierta cantidad de generaciones. Otra alternativa es el término al momento en que se encuentra una cadena sobre un valor de aptitud predeterminado. También la ejecución podría ser terminada cuando la población alcance cierto nivel de homogeneidad, es decir gran parte de las cadenas tiene la mayoría de los bits idénticos. Se deben usar criterios de términos ya que al ser una heurística, no es el objetivo de los GA encontrar óptimos, sino encontrar una buena solución en un tiempo razonable. En el caso de ser posible encontrar una solución óptima, en la mayoría de los casos no se puede determinar si esta se encontró.

3.6 Diseño De La Interfaz (GUI) En este punto se mostrará la GUI que interactuará con el usuario y el sistema

multiagente. Para hacer esto posible se utilizó el entorno JAVA con la plataforma NetBeans 8.0.1. El propósito de esta GUI es mostrar al usuario de forma más amigable la muestra de los datos luego de haber hecho la planificación con el sistema multiagente.

El usuario podrá interactuar con el sistema, pausando el proceso, para el proceso, ver en tiempo real que orden se está ejecutando, ver el tiempo de ocio que se genera en cada máquina y ver con colores, las ordenes de trabajo para su mejor comprensión y visualización.

A continuación, en el siguiente capítulo se describirá el desarrollo del sistema, su funcionamiento y explicación del algoritmo genético para llegar al óptimo.

19

4 Desarrollo del proyecto En este capítulo se darán a conocer la solución para conseguir los objetivos, y como se

van a implementar mediante diagramas.

4.1 Presentación del caso de estudio

Como se ha mencionado anteriormente el objetivo del proyecto es dar solución al problema de planificación Job Shop utilizando un Sistema Multiagentes. Para su mejor comprensión también se utilizará una GUI, en la cual el usuario tendrá la facilidad de ver gráficamente la solución propuesta por el sistema, mediante gráficos y reportes en lo que el usuario que el sistema genera.

4.2 Desarrollo del caso de estudio Como se mencionó en el capítulo 3, el sistema multiagente está compuesto de 6 agentes

que interactúan entre sí para dar solución a la planificación. Su solución será representada por la GUI, en la cual visualizará los tiempos de ejecución por cada máquina, tiempo de espera y porcentaje de progreso de cada orden de trabajo. Esta GUI mostrará un número de determinadas máquinas en donde las tareas se ejecutan.

Las metodologías de trabajo de los agentes están relacionadas con la metodología de desarrollo PASSI. A continuación se describen los resultados obtenidos de las actividades de desarrollo del sistema.

4.3 Modelo Sistema multiagente para Job Shop

4.3.1 Modelo de Requerimiento del sistema

4.3.1.1 Descripción del dominio

En la descripción del dominio se representa una visión general, basada en los casos de uso, de las funcionalidades del sistema en relación a lo expuesto en os puntos anteriores, referente a la arquitectura y al comportamiento de los agentes. (Véase anexo A Diagrama de descripción del dominio).

4.3.1.2 Diagrama de identificación de agentes

En el diagrama de identificación de agentes son representados paquetes de UML, y las funcionalidades asociadas a cada agente son representadas mediante casos de uso. Además, las relaciones entre casos de uso internos de un agente mantienen sus características originales, tales como <<extend>> o <<include>>, pero las relaciones entre casos de uso pertenecientes a distintos agentes, cambian a <<communicate>> por considerarse la forma natural en la cual los agentes interactúan. La Figura 4 muestra el diagrama de Identificación de Agentes para este proyecto y posteriormente se muestra la descripción de alto nivel de los casos de uso que componen el modelo.

20

Figura 3 Diagrama de identificación de agente

21

4.3.2 Diagrama de identificación de Roles

Este modelo representa los distintos roles que un agente puede tomar y las comunicaciones entre ellos, considerando que eventualmente durante una misma interacción un agente puede tomar varios roles. Para la representación de las comunicaciones se utilizan diagramas de secuencia de UML con ciertas variaciones, las que se refieren a la forma de nombrar los objetos participantes, que en este caso se nombran de la forma <Nombre Rol>:<Nombre Agente>. Los diagramas generados en este caso, están basados en los escenarios más representativos a los que deben enfrentarse los agentes de interfaz a desarrollar. En los anexos D y E, se muestra un diagrama diagramas de Identificación de Roles para los escenarios principales del procedimiento general.

4.3.3 Especificación de Tareas

En este paso se analiza un agente a la vez, representando cada uno mediante un diagrama de actividad. En este diagrama nodo de actividad representa una tarea que el agente debe realizar. De manera que, este diagrama resume el comportamiento de cada agente, así como, sus interacciones con otros. En el anexo F, G, H se especifican las tareas de dos de los principales agentes.

4.3.4 Modelo de Sociedad de Agentes

4.3.4.1 Descripción de la ontología de dominio

En el anexo I se muestra diagrama de clases muestra conocimiento atribuido a los agentes individuales y la pragmática de sus interacciones.

4.3.5 Modelo de Implementación de Agentes

En el Anexo J se muestra el diagrama de implementación de agentes

4.4 Implementación Algoritmo Genético para Job Shop Como se mencionó anteriormente se implementó un algoritmo genético para la

planificación del Job Shop. También en el capítulo 3, se habló sobre lo mínimo que tiene que tener un AG para su funcionamiento dando varias alternativas. A continuación se señalará los métodos que se utilizaron para el funcionamiento de la planificación.

4.4.1 Representación

La presentación se encuentra relacionada con los operadores, puede que existan algunos que no sean compatibles con la representación. Debido a ello se utilizara para los modelos una representación basada en operaciones.

Para la representación cada gen representa una operación dentro del cromosoma. Si bien hay 2 formas de representar las operaciones (binaria y natural), se utilizará la forma natural por su mejor compresión, aunque no todas las permutaciones de números naturales definen

22

schedules factibles. Gen, Tsujimura, y Kubota propusieron una forma alternativa: nombrar a todas las operaciones de un mismo job con el mismo símbolo y entonces interpretarlas de acuerdo al orden de ocurrencia en la secuencia para un cromosoma dado [34][35]. Para un problema de n jobs y m máquinas, un cromosoma contiene n . m genes. Cada job aparece en el cromosoma m veces, y cada repetición no indica una operación concreta de un job sino que se refiere a una operación la cuál es dependiente del contexto. Es fácil ver que cualquier permutación del cromosoma siempre produce un schedule factible.

Consideremos el problema de tres jobs y tres máquinas utilizado en [36] y presentado en la Figura 4. Supongamos el siguiente cromosoma [3 2 2 1 1 2 3 1 3], donde 1 indica el job j1, 2 el job j2, 3 el job j3. Como cada job tiene tres operaciones, tiene exactamente tres ocurrencias en el cromosoma. Por ejemplo, en el cromosoma hay tres 2, lo cual representa las tres operaciones del job j2:

Figura 4 Ejemplo de un problema de tres jobs y tres máquinas.

El primer 2 corresponde a la primer operación del job j2 la cual se procesará sobre la máquina 1.

El segundo 2 corresponde a la segunda operación del job j2 la cual se procesará sobre la máquina 3.

El tercer 2 corresponde a la tercera operación del job j2 la cual se procesará sobre la máquina 2.

Como se puede observar, todas las operaciones para el job j2 se denominan con el mismo símbolo 2 y se interpretan acorde al orden de ocurrencia en la secuencia del cromosoma. Las relaciones de ocurrencia correspondientes de las operaciones de jobs y máquinas de procesamiento se muestran en la Figura 5.

Acorde a esas relaciones, podemos obtener la lista de máquinas [ 2 1 3 1 2 2 1 3 3], como se muestra en la Figura 6. De esta figura se puede ver que el orden de procesamiento de jobs para la máquina 1 es 2 – 1 – 3 (indicado con el sombreado), para la máquina 2 es 3 – 1 – 2, y para máquina 3 es 2 – 1 – 3. En la figura 5, se muestra un schedule factible.

23

Figura 6 Orden de procesamiento de los jobs sobre la máquina 1

4.4.2 Función de Evaluación

La función de evaluación calcula el costo de los planes, en términos del tiempo consumido en total por los trabajos planificados, esto corresponde al cálculo de su makespan. Como al utilizar la representación señalada en la sección anterior se elimina la existencia de elementos infactibles al decodificar una permutación, la función de evaluación no requiere asignar una penalización al cromosoma por no respetar las restricciones de precedencia. Además como se busca minimizar el tiempo que consumen los planes, un valor fitness menor será considerado mejor que otro mayor.

4.4.3 Generación de Población Inicial

La construcción de los cromosomas pertenecientes a la población inicial, comienza formando cromosomas a través de una representación por operaciones, para los modelos se utilizara: Asignación Aleatoria de Trabajos.

En este tipo de asignación de trabajos se seleccionan aleatoriamente las posiciones de las m repeticiones de cada trabajo, hasta completar la permutación en el cromosoma, para luego utilizar el algoritmo de decodificación en un plan activo con el fin de determinar su makespan. Al utilizar este método, cada plan se encuentra totalmente determinado por el azar.

4.4.4 Selección

El mecanismo de selección escogido será la selección por torneo, explicada en el Capítulo 3 de este trabajo.

Figura 5 Operaciones de los jobs y correspondencia con las máquinas

24

Para ésta, la selección por torneo, se busca minimizar el tiempo total consumido por los trabajos al ser planificadas sus operaciones, por lo que el ganador del torneo resulta ser el que posea el menor valor de fitness, es decir una selección totalmente determinista.

Como el tamaño del torneo es fijado en dos, sólo compiten dos cromosomas en cada torneo, seleccionándose en total n/2 elementos de la población al finalizar.

4.4.5 Cruzamiento

Se utiliza el operador Generalized Order Crossover que es una modificación del operador OX. Su funcionamiento se explicará por medio de un ejemplo, supongamos que se tienen los dos padres siguientes:

Padre1

Padre2

Se selecciona un subconjunto de uno de los padres, en este caso la parte subrayada del primer padre. Estas operaciones son borradas del padre 2, es decir como el conjunto de genes seleccionado es (2,1) donde cada uno corresponde a la segunda operación de su respectivo trabajo, en el padre 2 se eliminara las segundas operaciones del trabajo 2 y del 1.

Entonces el padre 2 resultante es el siguiente.

Padre2

En este momento, las operaciones seleccionadas del Padre 1 son introducidas en las posiciones libres del Padre2, quedando la solución final como.

Hijo

4.4.6 Mutación

Para este trabajo se ha realizado la selección el operador intercambio Reciproco descrito en el capítulo 3

1 2 2 1 2 1

1 1 2 2 1 2

1 X 2 X 1 2

1 2 2 1 1 2

25

4.4.7 Sustitución

Posterior a los operadores de cruzamiento y mutación realizados a los cromosomas, es momento de recalcular la calidad de los nuevos individuos producidos. Si se producen menos cromosomas que el tamaño de población original, los nuevos cromosomas deben ser insertados en la población. De manera similar, si se producen más cromosomas que los necesitados o no todos son utilizados; se vuelve necesario un esquema de sustitución para determinar que cromosomas serán insertados en la nueva población.

El método de sustitución escogido, será la Sustitución Elitista donde se producen menos descendientes que el número de progenitores y de este modo se procede a reemplazar los peores progenitores.

4.4.8 Criterios de Término

Uno de los mecanismos de término más simples es el criterio de cantidad de generaciones el cual como se vio anteriormente consiste en terminar el algoritmo pasado una cierta cantidad de generaciones, éste es el criterio seleccionado.

26

5 Implementación y pruebas En este capítulo se darán a conocer los resultados de la planificación que realizó el

sistema, dando múltiples pruebas y comparando los resultados con la tesis de Gonzalo Jorquera, el cual realizó un Algoritmo Genético para Job Shop. También se mostraran los resultados de la GUI y la interacción que puede hacer el usuario con respectos a los resultados que muestra el programa.

5.1 Implementación del sistema

Para implementar lo expuesto en el capítulo anterior, en la plataforma escogida, en primer lugar se tomaron en cuenta los datos de prueba que serían utilizados. Para esta primera depuración de la arquitectura, fue necesario hacer ciertos ajustes en relación a la complejidad de la implementación el sistema completo y las pruebas que se realizarían.

La dinamicidad en la llegada de los clientes con sus órdenes de trabajo fue eliminada, esto, para poder hacer las comparaciones con los datos de prueba, ya que en su mayoría son estáticos, y también para probar la consistencia de la solución en forma estática. Otra simplificación fue, el no considerar tiempo en la solicitud de materiales a los Agentes Stock. Según la Figura 12, donde muestra la cantidad de máquinas y ordenes que se ejecutaran para realizar la planificación.

5.1.1 Obtención de los datos

Para que el sistema pueda funcionar, el sistema debe obtener la instancia de los datos. Estos están guardados en la carpeta Prueba, en la cual, se encuentran carpetas con las ordenes de trabajo y además un archivo de texto llamado “Entrada”. En este archivo se encuentran la cantidad de máquinas y ordenes con las cuales se trabajaran. Como muestra la Figura 7 Obtención de datos

Figura 7 Obtención datos

27

En la figura XX también se puede observar las carpetas de ordenes de trabajo. Por ejemplo un problema estático de 3 x 5 (3 máquinas y 5 órdenes para nuestro caso), se establecieron 5 carpetas llamadas Orden_C_{indice} Ej: Orden_C_1 . Cada carpeta contiene 3 archivos con los datos propios de cada tarea

La aplicación implementada leerá estos archivos e irá posicionando las tareas según lo dispuesto en los diagramas expuestos en el anterior capitulo.

Dentro de cada carpeta Orden se encuentran las tareas, las cuales, y por definición de Job Shop, tienen que ser la misma cantidad que las máquinas. En ellas se encuentra la información de cada tarea, como el id de la tarea, a qué máquina pertenece y el tiempo de proceso; como lo muestra la Figura 8

Figura 8 Obtención de tareas

5.1.2 Arquitectura Gui

Al obtener los datos registrados, se da inicio a la interfaz. Ésta consta de dos botones: uno de inicio de la planificación y otro de para mostrar un gráfico con los resultados. Ademas consta con 2 tablas, las cuales dan información, una sobre las máquinas, con tiempo de ejecución y con tiempo en las que estuvieron sin una tarea; y la otra tabla muestra la información sobre las órdenes de trabajo, su tiempo de ejecución y un botón para ver su planificación dentro del sistema. Por último dentro del menú archivo, hay una opción para generar un reporte, mediante un pdf, con los datos usados y los datos obtenidos. Esta interfaz se puede observar en la Figura 9

28

Figura 9 Programa principal

Otras capturas de pantallas se pueden ver en el anexo K de la figura 19 a la 23

5.2 Pruebas

5.2.1 Instancias de Job Shop

Como se mencionó es el sistema multiagente es el encargado del procesamiento de los datos. Sin embargo para encontrar una solución se ocupó un algoritmo genético

En esta etapa se procede a probar el rendimiento de los diversos modelos, para esto se utilizará diversas instancias, utilizadas en la tesis de Gonzalo Jorquera [33]

Las dimensiones de las instancias seleccionadas son:

abz7, abz8 y abz09: 15 x 20

mrt06: 6 x 6

mt10: 10 x 10

mt20: 20 x 5

ta11 y ta13: 20 x 15

29

Los resultados obtenidos serán comparados con dicha tesis, para lo cual se seleccionó un algoritmo para aquella tarea, la configuración es la siguiente.

Selección por torneo (tamaño del torneo es 2).

Crossover: GOX

Mutación: intercambio Reciproco

Tamaño de la población: 500.

Cantidad de generaciones: 1000

Probabilidad de mutación: 0.1, 0.15.

Sustitución elitista.

5.2.2 Resúmenes de Pruebas de Prototipos

Se procederá a ilustrar resultados de los prototipos generados, en base a la ejecución de las instancias antes mencionadas.

La configuración del sistema en el cual fue ejecutado los prototipos es el siguiente.

Procesador Intel Core i5 M430 a 2.27 GHz.

Memoria RAM de 4 GB.

Sistema Operativo, Windows 8 Home Edition.

Compilador Netbeans IDE 8.0.1

A continuación, en la Tabla 1 Comparación y resultado, se muestran los resultados obtenidos por el sistema, comparando los resultados con el proyecto Gonzalo Jorquera.

30

Tabla 1 Comparación y resultados

Set de datos Nº Generaciones Makespan Obtenido Makespan Comparado

abz07

(20x15)

1000 769 718

abz08

(20x15)

1000 785 762

abz09

(20x15)

1000 793 782

mt10

(10x10)

1000 877 974

mt20

(20x5)

1000 1185 1198

ta11

(20x15)

1000 1602 1618

ta13

(20x15)

1000 1573 1555

ta41

(20x15)

1000 2510 2312

Como podemos observar en la tabla XX, los resultados muy parecidos, lo que demuestra que el sistema está haciendo un buen trabajo. Sin embargo estas comparaciones solo demuestran, que los resultados están dentro de un rango aceptable del óptimo ocupando este algoritmo genético.

31

6 Conclusión En este trabajo se ha estudiado el problema de Job-Shop. Resultando el mayor interés

en este trabajo el estudio sobre los agentes y algoritmos genéticos en la resolución del problema. Desarrollándose un plan de trabajo, para lo cual se ha presentado el desarrollo del marco teórico del proyecto, por medio de la definición de objetivos, plan de trabajo y estudio conceptual de Job-Shop Scheduling Problem y Algoritmos Genéticos.

Se logró comprender la solución propuesta por Leonardo Espinoza, que fue de gran ayuda para lograr de mejor manera los objetivos del proyecto. Sin embargo se tuvieron que realizar varias modificaciones a su código (problema de optimización y de dinamismo) ya que solo se obtenía una solución y no buscaba soluciones más óptimas al problema.

También se logró entender el mecanismo del algoritmo genético. Uno de los factores influyentes para obtener una buena performance de los algoritmos evolutivos es la representación de las soluciones dentro del cromosoma. Por la existencia de restricciones de precedencia en las operaciones, no resulta fácil determinar una representación natural para el problema job shop scheduling. Un aspecto importante en la construcción de un algoritmo genético para el problema de job shop es determinar una representación apropiada de soluciones junto con operadores genéticos específicos del problema, de modo tal que el cromosoma generado, tanto en la fase inicial como en el proceso evolutivo, produzca schedules factibles. Esto es una fase crucial que afecta todos los pasos subsecuentes de un algoritmo evolutivo.

Combinando estas dos métodos de trabajo (agentes y genético), se logró obtener un sistema mucho más aceptable con la optimización, agregando además, una interfaz, lo que da un mejor entendimiento de la planificación de los datos y pudiendo analizarlos.

En conclusión, se logró obtener un sistema multiagente que logre resultados mucho más aceptables de lo que se tenía con el proyecto de Leonardo Espinoza y una interfaz, la cual no se tenía antes, que muestre los resultados a través de gráficos lo que da un mejor entendimiento de los datos y la planificación.

32

Referencias [1] Milan Schmotzer, Ján Paralič, y Július Csontó “Scheduling in a Multi-Agent

Environment”. TU Košice, Letná 9, 042 00 Košice, SLOVAKIA. 1998.

[2] http://www.utvm.edu.mx/OrganoInformativo/orgJul07/RUP.htm. Referenciado el 1 de abril del 2013.

[3] http://es.scribd.com/doc/59392631/Metodologias-de-Desarrollo-del-Software-word. Referenciado el 1 de abril del 2013

[4] Rusell y Norvig (1995), Artificial Intelligence: A Modern Approach.

[5] Wooldridge & Jennings (1995), Intelligent Agents: Theory and Practice.

[6] Ana Mas, “Agentes Software y Sistemas Multi-Agente: Conceptos, arquitecturas y aplicaciones”, Prentice Hall, ISBN 84-205-4367-5, 2005, pp 10-160.

[7] Weiss (1999), Multiagent Systems: A Modern Approach to Distributed Artificial Intelligence.

[8] Michael Wooldridge (2002), An Introduction to MultiAgent Systems.

[9] Fundation for intelligent physical agents, "FIPA ACL Message structure presentation," 2002.

[10] Fabio Bellifemine, Agostino Poggi, Giovanni Rimassa, “Developing Multi-agent Systems with JADE”, Wiley Editorial, ISBN 978-0-470-05747-6, 2001, pp 30-32.

[11] Piermarco Burrafato, Massimo Cossentino, “Designing a multi-agent solution for a bookstore with the PASSI methodology”, Dipartimento di Ingegneria Informatica, Centro di studio sulle Reti di Elaboratori-Consiglio Nazionale delle Ricerche c/o CUC, CiteSeer Computer and Information Science Conference, In Fourth International Bi-Conference Workshop on Agent-Oriented Information Systems AOIS, 2002, pp 3-17.

[25] Leonardo Espinoza Vera (2007) Desarrollo de un sistema Multi-Agente para el problema Job Shop, Pontificia Universidad Catolica de Valparaíso

[26] Watson, Jean Paul. “The Job-Shop Scheduling Problem”, Empirical Modeling andAnalysis of Local Search Algorithms for the Job-Shop Scheduling Problem., 2003.

[27] Jain, Anant Singh. MEeran, Sheik. “A State-Of-The-Art Review Of Job-Shop Scheduling Techniques”, Departament of Applied Physics, Electronics and Mechanical Engineering University of Dundee, Dundee, Scotland, 1998.

[29] JACOBSON, Ivar; BOOCH, Grady; RUMBAUGH, James. El Proceso Unificado de Desarrollo de Software. Pearson Addisson-Wesley. Año 2000

33

[30] http://www.utvm.edu.mx/OrganoInformativo/orgJul07/RUP.htm. Referenciado el 1 de abril del 2013.

[31] http://es.scribd.com/doc/59392631/Metodologias-de-Desarrollo-del-Software-word. Referenciado el 1 de abril del 2013

[32] John Henry Holland, Adaptation in Natural and Artificial Systems, University of Michigan Press, Ann Harbor, Michigan, 1975.

[33] Gonzalo Jorquera Martínez (2013) Utilización de algoritmo genético para problema Job Shop, Pontificia Universidad Católica de Valparaíso

[34] De Jong, K., Genetic algorithms: a 25 Years Perspective, in Computational Intelligence: Imitating Life, IEEE Press, New York, pag. 125-134, 1994.

[35] Kubota, A., Study on Optimal Scheduling for Manufacturing System by Genetic Algorithms, Tesis de Maestría, Ashikaga Institute of Technology, Ashikaga, Japan, 1995.

[36] Gen, M. y Runwei, C., Genetic Algorithms and Engineering Design, Wiley-Interscience Publication John Wiley & Sons, Inc, 1997.

1

Anexos

A: Diagrama de Descripción de Dominio (DD)

Figura 10 Diagrama de descripción de dominio

2

B: Diagrama de identificación de agentes

Figura 11 Identificación de Agentes

3

C: Representación Cruzamiento

Figura 12 Operador genético de cruzamiento de un punto

Figura 13 Operador genético de cruzamiento de dos puntos

Figura 14 Operador genético de cruzamiento multipunto

Figura 15 Operador genético de cruzamiento uniforme

4

D: Diagrama de identificación de roles: Ejecutar planeación de JobShop

Figura 16 Diagrama de identificación de roles: Ejecutar planeación de Job Shop

5

E: Diagrama de identificación de roles: Inicio

Figura 17 Diagrama de identificación de roles: Inicio

6

F: Especificación de Tareas: Agente inicio

Figura 18 Especificación de Tareas: Agente inicio

7

G: Especificación de tareas: Agente Orden

Figura 19 Especificación de tareas: Agente Orden

8

H: Especificación de tareas: Agente Planificación

Figura 20 Especificación de tareas: Agente Planificación

9

I: Descripción de la ontología de dominio

Figura 21 Descripción de la ontología de dominio

10

J: Diagrama de Implementación de Agente

Figura 22 Diagrama de Implementación de Agente

11

K: Capturas de pantalla

Figura 23 inicio interfaz

Figura 24 Cargando Planificación

12

Figura 25 Gráfico Planificación

Figura 26 Gráfico Job

13

Figura 27 Generar Reporte

Figura 28 Reporte en pdf