行政院國家科學委員會專題研究計畫 成果報告
運用 Alpha 演算法與 Petri-Net 探討代理人系統作業流程 之可行性
研究成果報告(精簡版)
計 畫 類 別 ： 個別型
計 畫 編 號 ： NSC 95-2221-E-011-015-
執 行 期 間 ： 95 年 08 月 01 日至 96 年 07 月 31 日 執 行 單 位 ： 國立臺灣科技大學工業管理系
計 畫 主 持 人 ： 歐陽超
計畫參與人員： 碩士級-專任助理：歐陽超、黎兆昇、王碩鴻、葉宗昀、鄒錦 銘
處 理 方 式 ： 本計畫可公開查詢
中 華 民 國 96 年 09 月 28 日
Applying Petri Net to Analyze a Multi-Agent System Feasibility -an α Algorithm Approach
C. Ou-Yang C.S. Li
Department of Industrial Management
National Taiwan University of Science and Technology 43, Sec. 4, Keelung Rd.
Taipei, Taiwan, 106
(Submitted to International Journal of Advanced Manufacturing Technology)
Abstract
Using agent development tools to construct an agent-based system is a popular approach. The developed agent system might not be feasible due to certain mutual conflicted rules stored in various agents. However, currently, the development tools do not have the function to check the feasibility of the workflow of the agent system during it implementation stage. Therefore, it is necessary to develop an evaluation approach to analyze the feasibility of a developing agent system. The improper workflow of an agent system can be found in the early design stage, and hence to reduce the risk of implementation.
In this research, a Petri Net based evaluation approach was developed. There were three stages in the proposed system. In the conceptual stage, the pitfall of the current agent system developing process was examined and an improvement analysis process was proposed. Then, in the system design stage, an evaluation approach which extracted the process log file from a developing agent system into a Petri Net model in terms of α algorithm. This model was imported into a Petri Net simulation package CPN. The agent system performance was evaluated in terms of analyzing the deadlock and infinite looping phenomena of the Petri-net model. Finally, in the implementation stage, the proposed concepts were implemented by integrating an agent developing tool JADE and CPN through certain JAVA based codes. An agent-based robotic assembly system was used to examine the possible deadlock the agent system.
Key Words：
Agent-based Systems, Workflow Feasibility, α algorithm, Petri Nets
1. Introduction
Recently, multi-agent systems have been applied in many fields such as manufacturing control, supply chain collaboration and e-commerce. It can be found that the agents required many business functions in order to interact properly among one another. For instance, in the supply chain collaboration, it might require the agents with planning, forecasting, production and inventory control capabilities to cooperate among each other. It also required frequent communications among these agents to achieve an acceptable performance. Therefore, as the application domain became more complicated, the interactions schema among the related agents also would be more sophisticated.
On the other hands, there are many approaches developed to design and develop a multi-agent system. Basically, the system development can be categorized as modeling stage, and system developing stage. In the system modeling stage, most of the developed modeling approaches, such as MaSE and WARP, were based on UML.
That is, the designer can apply various UML constructs such as use case diagram, sequence diagram and class diagram to model the behaviors of an agent system. In the system developing stage, several tools have been developed to assist the construction of an agent system. For instance, ZEUS is a graph based tool, users can generate agents and built rules in terms of several build-in constructs. Another popular agent development tools is JADE. It is a JAVA based environment contained many components can be used to construct an agent system.
Currently, most of the development tools still lack of the capability of system verification. That is once an agent system was constructed, it is necessary to assure that the system can be operate feasibly. In this research, an evaluation approach was developed, which extracted the process log file from a developing agent system and then transferred into a Petri Net model in terms of α algorithm. The agent system feasibilities were evaluated in terms of analyzing the deadlock of the Petri-net model.
2. Background
Cooperation among various organization units through internet has been addressed heavily in the recent period. Applications such as collaborative design/production activities in terms of product development management (PDM) tools, or Collaborative Planning Forecasting and Replenishment (CPFR) through a supply chain are the few examples. Among the various collaborative application methodologies, agent based approaches had been focused in many areas. In the shop floor manufacturing, agent systems had been used to support the collaboration among the controllers of various manufacturing facilities. For instance, an agent-based discrete shop floor control
system was developed to coordinate and control a range of shop floor facilities such as CNC and conveyor [Schoop 01]. Another work addressed on developing an agent-based production control framework for elevator industry. The agents in this framework could cooperate with each other to achieve lower production cost [Lu 05].
Also, a multi-agent control framework had been developed to support the concept of networked manufacturing. This framework tended to apply agent to integrate various industrial application tools to improve the production efficiency. The proposed concept also implemented in an area in China [Fan 05]. In addition, agent-based emulation system was developed to assist a manufacturing system to reach the status of lean manufacturing. This system applied distributed agents to analyze and simulate the production schedule for a pull-based production system [Ivezic 99].
Several works also addressed on the agent-based supply chain collaboration. For instance, an artificial neural network approach had been used in an agent-based supply chain network to enable the planning tasks. The experimental results showed that the performance about order fulfillment and resource utilization had been improved significantly [Chiu 04]. Another approach had linked the intelligent agent with a CPFR process for trading partner negotiation. Two kinds of agent models (advanced model and learning model) had been proposed. The experimental results showed that these models achieved advantages in terms of inventory-level, stock out level [Caridi 05]. In addition, an agent based negotiation model was proposed to support the collaboration of individual enterprises during the project configuration stage in a supply chain [Lau 05].
In addition to the area of manufacturing industries, e-commerce was another field focused on agent-based collaboration. An on-line bargaining systems was proposed by Lin et al.. This multi-agent system including three separate agents could be used in a dynamic price issuing and matching environment [Lin01]. Another multi-agent system InterMarket was developed to assist the user to find the potential business opportunities in an on-line marketplace. In terms of two types of agents, mobile agent and intelligent agent, this system could find the potential trading opportunities for the intended sellers or buyers and improve the success probabilities of the trading events [Kowalczyk 02].
In addition to the related research, several agent-based analyze methods and implementation tools had been developed. DeLoach had proposed a Multiagent Systems Engineering (MaSE) approach for the tasks of agent system design. This approach modified from the famous Object Modeling Technique (OMT) and Unified Modeling Language (UML), such that it could easily decompose the problem domain and describes the coordination and communication activities among multiple-agents [DeLoach 99]. Another analyzing approach Gaia dealing with both macro and micro
level aspects of a design and has developed its own modeling constructs and language [Wooldridge 00]. As for the graphic-based implementation tools, ZEUS seems a convenient tool. It is a JAVA based toolkit, which provides a visualized design environment. Also, an agent library is provided such that the designer can easily extend the functions of related agents [Nwana 99].
Once an agent-based system has been developed, its performance should be verified. Various methods have been used. For instance, a simulation approach has been used to Most of the research works in system verification were based on simulation. For instance, a simulation approach has been used to verify that the strategies made by a cooperative agent system could reach a convergence value for a manufacturing environment [Deen 06]. Another verification rule schema has been developed for a cooperative traffic agents system to validate the situation such as the worst case behaviors of a traffic system [Damm 06].
In addition to the works on performance verification, very few researches were addressed on the agent system feasibilities verification. The system feasibilities indicated that an agent system could be carried out smoothly in most of the conditions.
The methods for feasibilities verification can be found in few modeling tools such as Petri net. For instance, the deadlock of a Petri-net can be analyzed by calculating the state transformation matrix of the net. The system bounded condition can verified in terms of the place invariant properties of the net.
As for the agent system feasibility verification, the UML based modeling tools still cannot verify certain feasibility situation such as deadlock or infinite-loop of an agent system. However, these situations could occur and difficult to observe for a complicated multi-agent system during its developing stage. For instance, for a multi-agent system with three agents and each agent contained many rules. If there were three rules: IF A THEN B; IF B THEN C; IF C THEN A, in each of the three agents respectively. Then, an infinite loop might occur in the agent system if these rules were triggered one after another. However, it would be very difficult to observe these situations if the system designer only inspected the rules in each agent separately.
In this research, an evaluation approach which extracted the process log files from an agent system and transferred into a Petri-net model in terms of α algorithm would be proposed. This transferred model was imported into a Petri net simulation package CPN. The agent system feasibilities were evaluated in terms of analyzing the deadlock and infinite looping phenomena of the Petri-net model.
3. The Proposed Evaluation Framework
A three stage approach has been proposed to support the feasibility analysis of
an agent system (Fig-1). In the conceptual stage, the concept of using the behavior information for verifying of an agent system was discussed. Then, in the design stage, an approach of extracting the behavior information from the testing agent system and transforming into a Petri net system in terms of α algorithm was proposed. The feasibility of the agent system would be examined based on the simulation results of the respective Petri net. Finally, in the implementation stage, the proposed approach would be implemented in terms of the agent development tool, JADE and a Petri net tool Colored Petri Net (CPN). Two examples would be used to examine the proposed concepts.
3.1 The Conceptual Stage
In most of the multi-agent system development processes (Fig-2-1), a system analysis would be performed first by using UML related tools. Then, a verification model would be built in terms of certain simulation tool such as Petri net (PN). The PN model would be simulated and analyzed to verify the system performance. If the verification results could be accepted, an agent system would be built and implement.
The main consideration of this approach was that most of the PN based simulation model could only reflect certain pre-defined conditions of the domain. It would be difficult to represent a domain with complicated conditions. For instance, if each of the agents contained many rules in a multi-agent system, it would be difficult to develop an UML model and related PN model to reflect most of the possible conditions.
This research applied another system development processes (Fig-2-2). An agent system would be constructed based on UML analysis. The constructed system would be tested and the triggering sequence of the system would be recorded in a log file.
Then, the contents of the log file would be transferred to a PN model through α algorithm. The transferred PN model would be simulated and certain infeasible conditions such as deadlock or infinite loop could be verified through the simulation data. Finally, the verified system would be implemented. The main features of this approach were that it could reflect certain dynamic conditions, which were not expected during the system analysis stage, occurred during the system test phase.
3.2 The Design Stage
The main objective of this section was to develop an approach to verify the feasibility of an agent system. The basic idea was to extract the interaction information from a multi-agent system and then transfer the behaviors of the extracted data into a PN. The main issue in this stage was how to transfer the information about the agent interactive logic into a proper PN model. In this work, α algorithm was
applied and modified to fulfill this goal.
Table-1 showed the hypothetical data extracted from an agent system. Basically, each “case” represented a process carried out by the agent system and each “task”
indicated a rule fired by a specific agent. Therefore, in this test data, there are five processes carried out by the agent system in a common period of time, and five rules were fired by various agents during that time period.
Based on Table-1, the recorded data can be represented as: case 1: {a,b,c,d}, case 2 :{a,c,b,d}, case 3 :{a,b,c,d}, case 4:{a,c,b,d} and case 5:{e,f}. It means that for process “case 1”, four rules were fired as the sequence of a, b, c, d.
Appendix-A showed α algorithm. The related PN can then be transferred based on the following procedure:
1. Find the transition set: TW={a,b,c,d,e,f}.
2. Find the set of initial transitions: TI={a,e}.
3. Find the set of final transitions: TO={d, f}
4. Find the set of transitions which has only one directional precedence: XW={(a,b), (a,c), (b,d), (c,d), (e,f)}
5. Remove the duplicated transition sets. YW={(a,b), (a,c), (b,d), (c,d), (e,f)}
6. Develop the place set: 1. add a place construct to each of the transition set, 2. add the initial and final place constructs. Pw={iW, p(a, b), p(a, c), p(b, d), p(c, d), p(e, f), oW}
7. Develop the arrow set to link the places and transitions. Fw={(iW, a), (a, p(a, b)), (a, p(a, c)), (p(a, c), c), (p(a, b), b), (b, p(b, d)), (c, p(c, d)),( p(b, d), d) , (p(c, d), d) ,(d, ow), (iw, e), (e, p(e, f)), (p(e, f), f), (f, oW)}
8. Complete the final PN: α(w)=(PW, TW, FW)
The transferred PN was shown in Fig-3. It can be found that α algorithm is suitable for transforming one process log file into respective PN model. However, in the multi-agent system, each agent might have its own log file. Therefore, α algorithm should be modified to reflect this situation.
3.2.2 Multi-Agent System Application and Modified α Algorithm
This research would be addressed on a multi-agent system where a pair of agents would be interacted with one another each time. That is, although there were several agents in a system; however, only two agents would be communicated with one another each time.
According to Aalst et al. work, if a task was directly followed task b in a log file, then task b is “direct succession” of task a [Aalst 04]. This situation could occur in a multi-agent system. If one agent sent a request signal to another agent and wait until the reply signal was received, then the tasks of sending and receiving signals would form a “direct succession” relation. However, in a multi-agent system with this
situation, this information might be duplicated in the log files of these two agents. For instance, in Fig-4-1, Agent I would send a request for service information (Task b) to agent II. Then, Agent II would send a reply signal back to Agent I (Task c) (Fig-4-2).
Task b and Task c formed a direct succession relation. However, these tasks would appear in the log files of both agents. Moreover, from the PN model points of view, since Agent I played an active role at the predecessor task and Agent II played a passive role at the successor task in this directive succession relations, there should be two places which could directly enable the transitions with respective to Task b and Task c respectively. Therefore, α algorithm should be modified to reflect this multi-agent interactive situation.
Fig-5 showed the modified α algorithm. Basically, the main modification was to add a step (Step-6) into the original algorithm. The main role of this step was to find the succession task from the set of duplicated tasks in two agents’ log files. Based on the log files shown in Fig-4-1 and Fig-4-2, the related PN can be translated according to the following procedure:
1. Find the transition set: TW1={a,b,c,d}, TW2={b,c}
2. Find the initial transition set: TI={a,b}
3. Find the final transition of each set: TO={d,c}
4. Find the set of transitions which has only one directional precedence: XW={(a,b), (b,c), (c,d), (b,c) }
5. Remove the duplicated transition set. YW = XW –(b,c)={(a,b), (b,c) (c,d),}
6. For the duplicated transition set find the successor transition. T’I={c}.
7. Develop the place set: PW={iW1,iW2, p(A, B), p(B, C), p(C, D), oW}
8. Develop the arrow set to link the places and transitions. FW={(iW1, a), (a, p(a, b)), (p(a, b), b), (b, p(b, C)), (p(b, c) ,c), ( iW2,c), (c, p(c, d)), (p(c, d), d), (d, oW),
9. Complete the final PN: α(W)=(PW, TW, FW)
The translated PN was shown in Fig-4-3. This model can then be simulated in terms of certain commercial tools for further analysis.
3.3 The Implementation Stage
In this stage, the multi-agent system would be implemented in terms of JADE (Java Agent Development Framework). The experimental agents and their related rules would be built in. During the execution period, the “sniffer agent” in JADE would be used to trace the interaction messages among the agents. The traced information would be written into log files. Then, α algorithm transformation module would be used to generate a related PN model. This model would be put into PN software CPN (Color Petri-net) for simulation. The generated report could be used to verify the feasibility of the related multi-agent system.
4. Empirical Verification
The proposed approach has been implemented and verified in terms of a robotic assembly cell example from Zhou’s book. [Zhou 93]. In this book, Zhou modeled the assembly behaviors as a PN model and then proved that possible deadlock might occur in this system.
Fig-6 showed the assembly cell. There are two robots and two assembly stations.
Each station required both of the robots to carry out an assembly job. If workstation 1 required performing the task, it would acquire robot 1 first. Once it got the authorization of robot 1, it would acquire robot 2. For workstation 2, the sequence of acquiring robots would in a reverse way. Therefore, it could be found that if both of the workstation 1 and 2 acquired robots at the same time, then, neither of them could get another robot. The assembly cell would be in a deadlock situation.
The empirical assembly cell has been implemented as a multi-agent system in terms of JADE. Fig-7 showed the implementation framework. In general, four agents would be developed to represent the control behaviors of two robots and two workstations respectively. In the JADE distributed agent platform, each agent should register and get a unique ID from Agent Management System (AMS). During the run time, two robot agents should register in the Directory Facilitator (DF) first. Once an assembly workstation agent required a robot service, it could require the DF to search for the available robot agent. These agents would be communicated among one another through the Agent Communication Channel (ACC). Therefore, the ACC would store the communication data. A sniffer agent would be developed to extracted the data and generate the log files for each agent.
4.1 Log Files Generation
Fig-8 showed the window of the sniffer agent and its retracted information. In the left side of the window, it showed that the four developed agents (R1: Robot 1, R2:
Robot 2, WS1: Workstation 1, and WS2: Workstation 2) as well as the AMD and DF.
The right side of the window showed the sequence diagram for the process of WS1 requesting R1 agent and R2 agent. The communication messages among these agents were shown in the bottom of the diagram. The information about the log files was extracted from the message files.
The sequence diagram showed in the sniffer agent window indicated the sequence for WS1 requesting R1 and R2 robots. Mainly, the WS1 would send a
“request” to DF for searching required robot. Then, DF would acknowledge WS1’s request through “inform” message. In the third stage, W1 would “request” R1 for service, and R1 would “agree” the service in the fourth stage. Then W1 would
“request” R2 in the fifth stage. The information and sequence about these tasks can be extracted from the message file of sniffer agent and converted into the log file for W1 agent as shown in Table-2.
The information about the log files for W2, R1 and R2 also can be extracted from the same message file and were shown in Table-3, Table-4 and Table-5. It can be found that W2 would be refused by R2 since it already assigned to W1. As for the log file for R2, it showed that it agreed the request from W1 and refused R2.
4.2 Log Files Conversion to PN Model
Once a log file has been created, the next stage was to convert the log file into a PN model. For the WS1 log files as shown in Table-1, its log file can be shown as {REQUEST, INFORM, REQUEST, AGREE, REQUEST, AGREE, CANCEL, CANCEL}and{ REQUEST, INFORM, REQUEST, AGREE, REQUEST, AGREE, CANCEL, CANCEL}. Table-6 showed the messages in the log file and their mapped symbols. It can be found that although the messages for G and H are CANCEL, G was the message sent from WS1 to R1 and H was sent from WS1 to R2.
According the log file, the respective PN can be transferred as the following steps:
1. Find the transition set: TW={A, B, C, D, E, F, G, H}。
2. Find the initial transition set: TI={A}。
3. Find the Final transition set: TO={G, H}。
4. Find the set of transitions which has only one directional precedence: XW={(A, B), (B,C), (C,D), (D,E), (E,F), (F,G), (F,H)}.
5. Remove the duplicated transition set. There was no duplicated set in this log file.
So, YW= XW ={(A, B), (B,C), (C,D), (D,E), (E,F), (F,G), (F,H)}.
6. Develop the place set: PW={iW, p(A,B), p(B,C), p(C,D), p(D,E), p(E,F), p(F,G), p(F,H), oW}.
7. Develop the arrow set to link the places and transitions: FW={(iW, A), (A, p(A,B), (p(A,B), B), (B, p(B,C)), (p(B,C), C), (C, p(C,D)), (p(C,D), D), (D, p(D,E)), (p(D,E), E), (E, p(E,F)), (p(E,F), F), (F, p(F,G)), (F, p(F,H)), (p(F,G), G), (p(F,H), H), (G, oW), (H, oW)}.
8. Complete the final PN: α(w)=(PW, TW, FW)
The converted PN model and the definition of places and transitions were shown in Fig-1 and Table-7 respectively.
The next task was to transfer the log files for R1 and R2 into the model. From Fig-9, it can be found that the messages for the three stages of the R1 agent were the same as the stage 3, 4 and 7 of W1 agent (link 1 and 2 in Fig-9). In addition, W1 played an active role and R1 played a passive role in this communication. According
to the modified algorithm, a place can be added to the first “AGREE” transition in the PN model. The similar situation also can be found in the log files for W1 and R2 agents (link 3 and 4 in Fig-9). Therefore, another place can be added to the second
“AGREE” transition in the PN model. The PN model from the W1 agent point of view was shown in Fig-10-1.
The third task was to build the PN model based on the log file of W2 agent (Table-3) and to add the information about R2 agent (link 5 in Fig-9) into the model.
The PN outcome was shown in Fig-10-2.
The above model was built based on the situation that W1 would issue requests to R1 and R2 before W2 agent. Another situation was that W2 would issue requests to R1 and R2 earlier than W1. Since the dilemma would be the same as the previous case, except that the contents of the log files for W1; W2 and R1; R2 would be inter-changed with each other when compared with log files shown from Table-2 to Table-5. Therefore, the transformation process of the PN model basically would be the same as the previous tasks, and the final PN model was shown in Fig-10-3.
The constructed PN model was simulated through CPN (Colored Petri-Net) tool.
As mentioned before, the empirical assembly cell would encounter a deadlock if W1 issued a request to R1 and W2 sent a request to R2 at the same time. This situation can be simulated through the PN model by issuing two tokens at place “WS1” and WS2” respectively. The CPN report was shown in Table-8. It can be found that two tokens were halted in place P5 and P12 respectively. From the PN model, P5 indicated that W1 was waiting the response from R2, and P12 specified that W2 was waiting the response from R1. Since both of the assembly workstation occupied a robot and waited another robot, a deadlock would happen.
5. Discussion and Conclusions
This research tried to bridge the gap between a multi-agent systems and a PN tool, such that the developed PN model can be used to simulate and to assist the analyzing the feasibility situation, such as deadlock, of the multi-agent system. The major contributions of this work were:
1. The concept of verifying the feasibility of a multi-agent system during its developing stage can be accomplished.
2. A transformation approach was developed to transfer the log files of a multi-agent system into its respective PN model.
Several possible issues were also worth to be considered. One was that in this work, α algorithm was modified such that the log files for two interactive agents can be transformed to a PN model. The main assumption of the modification was based that two agents should have “direct succession” relation. That was two agents would
send a “request” and “response” messages between each other in the beginning of the interaction. However, in the real environment, the phenomena for agent interaction might be more complicated. For instance, if two agents both have reactivity property, they might have interaction due to the trigger from outside environment. One possible example was that if the inventory level was lower than the safety level, an inventory control agent might send a replenishment order to the supplier agent without sending the “request” message first. Since these agent might not have a common “request”,
“response” messages in their log files, the modified α algorithm could not link these agents in a PN model.
Another possible future work was to use the transferred PN model to assist the design of a multi-agent system. This research was only addressed on transferred the log files into a PN model for the purpose of feasibility analysis. However, the transferred PN could be used to assist the re-design of the agent system. For instance, the PN properties such as place invariant and transition invariant can be used to control certain behaviors of an agent-based manufacturing system [*****]. Therefore, it possible to add certain place and transition constructs into the converted PN model such that the related agent system can fulfill certain phenomena. In order to achieve this, an inverse-α algorithm might also need to be conducted.
Acknowledgement
The authors would like to acknowledge the financial support by National Science Council, Taiwan, through project no. NSC-92-2213-E-011-035.
Reference
[Aalst 04] W.M.P. van der Aalst, A.J.M.M. Weijters, and L. Maruster, “Workflow Mining: Discovering Process Models From Event Logs”, IEEE Transactions on Knowledge and Data Engineering, Vol. 16, No. 9, Sep 2004.
[Caridi 05] M. Cardid, R. Cigolini and D.D. Marco, “Improving Supply Chain Collaboration by Linking Intelligent Agent to CPFR”, International Journal of Production Research, Vol.43, No.20, 2005, p4191-p4218.
[Chiu 04] M. Chiu and G. Lin, “Collaborative Supply Chain Planning Using the Artificial Neural Network Approach”, Journal of Manufacturing Technology Management, Vol.15, No.8, 2004, p787-p796.
[Damm 06] W. Damm, H. Hungar and E.R. Olderog, „Verification of cooperating traffic agents”, International Journal of Control, Volume 79, Number 05, 2006, p395-p421.
[Deen 06] S. M. Deen and R. Jayousi, “A Preference Processing Model for Cooperative Agents”, Journal of Intelligence Information System, Vol.26, 2006, p115-p147.
[DeLoach 99] S.A. DeLoach, “Multiagent Systems Engineering: A Methodology and Language for Designing Agent Systems”, Proceeding of Agent-Oriented Information Systems (AOIS), 1999.
[Fan 05] Y. Fan, C. Huang, Y. Wang and L. Zhang, “Architecture and Operational Mechanism of Networked Manufacturing Integrated Platform“, International Journal of Production Research, Vol. 43, No.12, 2005, p2615-p2629.
[Ivezic 99] N. Ivezic, T.E. Potok, L. Pouchard, “Multiagent Framework for Lean Manufacturing”, IEEE Internet Computer, Volume: 3 Issue: 5, 1999, p58-p59.
[Kowalczyk 02] R. Kowalczyk, B. Franczyk, A. Speck, P. Braun, J. Eismann, and W.
Rossak, “InterMarket-Towards Intelligent Mobile Agent e-Marketplaces”, Proceedings of 9th Annual IEEE International Conference and Workshop on Engineering of Computer-Based Systems. 2002, p268 -p2752.
[Lau 05] J.S.K. Lau, G.Q. Huang, K.L. Mak and L. Liang, “Distributed Project Scheduling with Information sharing in Supply Chains: Part i: an Agent-based Negotiation Model”, International Journal of Production Research, Vol. 43, No.22, 2005, p4813-p4838.
[Lin01] F.R. Lin and K.Y. Chang, “A Multi-Agent Framework for Automated Online Bargaining”, IEEE Intelligent Systems, Volume 16 Issue 4, 2001, p41-p47.
[Lu 05] T.P. Lu, T.M. Chang and Y. Yih, “Production Control Framework for Supply Chain Management-an Application in the Elevator Manufacturing Industry”, International Journal of Production Research, Vol. 43, No.20, 2005, p4219-p4233.
[Nwana 99] H. Nwana, D. Ndumu, L. Lee and J. Collis, “ZEUS: A Tool-Kit for
Building Distributed Multi-Agent Systems”, Journal of Applied Artificial Intelligence, Vol.13, 1999, p187-p208.
[Schoop 01] R. Schoop, R. Neubert, and A.W. Colombo, “A Multiagent-based Distributed Control Platform for Industrial Flexible Production Systems”, IECON '01.
The 27th Annual Conference of the IEEE Industrial Electronics Society, Volume.1, 2001, p279 -p284.
[Wooldridge 00] M. Wooldridge, .R. Jennings and D. Kinny, “The Gaia Methodology for Agent-Oriented Analysis and Design”, Autonomous Agents and Multi-Agent Systems, Vol.3, 2000, p285-p312.
[Zhou 93] M. Zhou, Petri Net Synthesis for Discrete Event Control of Manufacturing Systems, Kluwer Academic Publishers, 1993.
Conceptual Stage Design Stage
Agent Rules Design
Agent System Simulation
Record Log File Build PN
PN Simulation
and Analysis
Modify Agent System
Construct &
Implement Agent System
α algorithm
Yes No
Implementation Stage
Fig-1 Proposed framework
System Analysis
Agent System Construction Agent PN
Model Construction
System
Simulation Modify? Agent System
Implementation Yes
No
(1)
System Analysis
Agent System Construction
Agent System Test
Agent PN Model Construction
System
Simulation Modify? Agent System
Implementation
Collect data
No Yes
(2)
Fig-2 (1) The original agent development process, (2) The proposed agent development process
Fig-3 (reference)
Process Operation Notation Case 1 Task a Beginning Task
Case 1 Task b(Request) Agent I send a request to Agent II
Case 1 Task c(Agree) Agent II agree with Agent I
Case 1 Task d Ending Task
(1)
Process Operation Notation
Case 2 Task b(Request) Agent I send a request to Agent II Case 2 Task c(Agree) Agent II agree with Agent I
(2)
(3)
Fig-4 Information for scenario 1, (1) log file for agent I, (2) log file for agent II, (3) The PN for agent I and agent II
Task a Task b Task c Task d
Agent I
Agent II
) , , ( ) ( . 9
} T t
| ) , {(
}
| ) {(
} T t
| ) , {(
} B Y
B) (A, | ) , { } A Y
B) (A, | , {(
. 8
}, , { } ) B , A ( {
. 7
} )
B , A ( A
T B) , A (
| ) B , A ( {
T . 6
)}
B , A ( ) B , ( B B A A X
B) A, {(
Y . 5
} b
# b a
# a
b T
B T A B) A, {(
X . 4
)}
( T
{t T . 3
)}
( T
t { T . 2
}, T
t { 1.T
o '
, I
W )
, A ( W
) , ( ) , (
' w
'
' ' '
' )
B , A w ( w
2 1 B b , b 2 1 A , a
B b A a w w
w
w O
w I
w wi
' '
2 1 2
1
w w w
I w w
w
B B
A W
i W W W B
A W
w W I
X w w
a
w
F T P W
o t T
t t i t
i
b b
p a
p a F
n i o i Y p
P
T B
last t
A last
t first t
n i t
w
=
∈
∪
∈
∪
∈
∪
∈
∧
∈
∪
∈
∧
∈
=
∈
∪
∈
=
⊆
∧
→
∧
⊆
∈
=
=
⇒
⊆
∧
⊆
∀
∈
=
∀
∧
∀
∧
→
∀
∀
∧
⊆
∧
⊆
=
∈
∃
∈
=
∈
∃
∈
=
∈
∈
∃
∈
=
∈
∈
∈
∈
∈
∈
∈
∈
α
σ σ σ
σ σ σ
Fig-5 Modified α algorithm
Fig-6 The robotic assembly cell
Fig-7 Robotic assembly cell in JADE
Fig-8 JADE window and the generated communication messages
Sender
WS1/R2 CANCEL
8
WS1/R1 CANCEL
7
R2/WS1 AGREE
6
WS1/R2 REQUEST
5
R1/WS1 AGREE
4
WS1/R1 REQUEST
3
DF/WS1 INFORM
2
WS1/DF REQUEST
1
sender/receiver Messages
Stage
R2/WS2 REFUSE
4
WS2/R2 REQUEST
3
DF/WS2 INFORM
2
WS2/DF REQUEST
1
sender/receiver Messages
Stage
WS1/R1 CANCEL
3
R1/WS1 AGREE
2
WS1/R1 REQUEST
1
sender/receiver Messages
Stage
R2/WS2 REFUSE
5
WS2/R2 REQUEST
4
WS1/R2 CANCEL
3
R2/WS1 AGREE
2
WS1/R2 REQUEST
1
sender/receiver Messages
Stage
W1 Agent
W2 Agent
R1 Agent
R2 Agent 1
2
3 4
5
Fig-9 The interactions among the four agents
) , , ( ) ( . 8
} T t
| ) , {(
} T t
| ) , {(
} Y
B) (A, | ) , { } Y
B) (A, | ,
{(
. 7
} , { } ) , ( {
. 6
)}
, ( ) , ( B B A A X
B) A, {(
Y . 5
b
# b
a
# a b
T B T A B) A, {(
X . 4
)}, ( T
{t T . 3
)}, ( T
t { T . 2
}, T
t { 1.T
o I
W )
, ( W
) , ( ) , (
' ' '
' )
B , A w ( w
2 1 B b , b
2 1 A , a B
b A a w w
w
w O
w I
w w
' ' 2
1
2 1
w w w
w w
B A B
A W
W W W
B A W
X w
w a
w
F T P W
o t t
i
B b b
p A a p
a F
o i Y
B A p
P
B A B A last
t
first t
t
w
=
∈
∪
∈
∪
∈
∧
∈
∪
∈
∧
∈
=
∪
∈
=
=
⇒
⊆
∧
⊆
∀
∈
=
∀
∧
∀
∧
→
∀
∀
∧
⊆
∧
⊆
=
∈
∃
∈
=
∈
∃
∈
=
∈
∃
∈
=
∈
∈
∈
∈
∈
∈
∈
∈
α
σ σ σ
σ σ σ
(1)
(2)
(3)
Fig-10 (1) W1 agent oriented PN model, (2) W2 agent oriented PN model, (3) the final PN model
Process Operation
case 1 task a
case 2 task a
case 3 task a
case 3 task b
case 1 task b
case 1 task c
case 2 task c
case 4 task a
case 2 task b
case 2 task d
case 5 task e
case 4 task c
case 1 task d
case 3 task c
case 3 task d
case 4 task b
case 5 task f
case 4 task d
Table-1
Stage Messages sender/receiver
1 REQUEST WS1/DF
2 INFORM DF/WS1
3 REQUEST WS1/R1
4 AGREE R1/WS1
5 REQUEST WS1/R2
6 AGREE R2/WS1
7 CANCEL WS1/R1
8 CANCEL WS1/R2
Table-2 The log file for W1 (workstation1 ) agent
Stage Messages sender/receiver
1 REQUEST WS2/DF
2 INFORM DF/WS2
3 REQUEST WS2/R2
4 REFUSE R2/WS2
Table-3 The log file for W2 (workstation2 ) agent
Stage Messages sender/receiver
1 REQUEST WS1/R1
2 AGREE R1/WS1
3 CANCEL WS1/R1
Table-4 The log file for R1 (Robot1 ) agent
Stage Messages sender/receiver
1 REQUEST WS1/R2
2 AGREE R2/WS1
3 CANCEL WS1/R2
4 REQUEST WS2/R2
5 REFUSE R2/WS2
Table-5 The log file for R2 (Robot2 ) agent
Messages REQUEST INFORM REQUEST AGREE
Symbol A B C D
sender/receiver WS1/DF DF/WS1 WS1/R1 R1/WS1
Messages REQUEST AGREE CANCEL CANCEL
Symbol E F G H
sender/receiver WS1/R2 R2/WS1 WS1/R1 WS1/R2
Table-6 The messages and its mapped symbols for the log file of WS1
Place Definition
WS1 WorkStation Agent 1 P1 Wait for DF response
P2 Get DF response and prepare send message to R1 P3 Wait for R1 response
P4 Get R1 response and prepare send message to R2 P5 Wait for R2 response
P6 Using R1 to assemble P7 Using R2 to assemble P15 Set R1 and R2 as “idle”
Transition Definition
REQUEST Request DF to search the idle robot agent INFORM DF inform the search result
REQUEST Request R1 service AGREE R1 agree
REQUEST Request R2 service AGREE R2 agree
CANCEL R1 finish assembly CANCEL R2 finish assembly
Table-7 Definitions of places and transitions in Fig-10-1
Boundedness Properties
---
Best Integers Bounds Upper Lower
New'P10 0 0
New'P1 0 0
New'P11 0 0
New'P12 1 1
New'P13 0 0
New'P14 0 0
New'P2 0 0
New'P3 0 0
New'P4 0 0
New'P5 1 1
New'P6 0 0
New'P7 0 0
New'P8 0 0
New'P9 0 0
New'R1 0 0
New'R1 0 0
New'WS1 0 0
New'WS2 0 0
Liveness Properties
--- Dead Markings: All
Dead Transitions Instances: All Live Transitions Instances: None
Table-8 CPN simulation results
