JP3722970B2 - Agent system monitoring apparatus, monitoring method, and recording medium recording monitoring program - Google Patents

Description

[0001]
BACKGROUND OF THE INVENTION
The present invention relates to an improvement in technology for processing information existing in a distributed manner on a network using an agent, and in particular, increases the flexibility and safety of operation by the agent.
[0002]
[Prior art]
[Agent system]
Conventionally, an agent system is known as a technique for processing information distributed on a computer network. An agent is a processing unit on software, and operates autonomously according to surrounding conditions. The agent system is a system in which such an agent performs processing such as information collection while moving as necessary on the nodes constituting the network. Here, a node is a logical unit constituting a network, and a plurality of nodes may exist on one machine, that is, a computer.
[0003]
FIG. 7 is a functional block diagram showing a configuration example of the agent system proposed by the present applicant in Japanese Patent Application No. 7-176181 as an example of such an agent system. The agent system shown in this figure has a plurality of nodes 800 connected by a network 800N, and FIG. 7 illustrates only two of the nodes that can be provided in large numbers. Of the nodes 800, a node used by the user for agent generation is called a local node (800L), and a node to which the generated agent moves is called a remote node (800R).
[0004]
In this agent system, each node 800 has input / output means 803 (L, R) for a user to perform an operation for generating an agent and receive a result of information processing by the agent. Further, the agent management means 804 (L, R) of each node generates an agent, deletes an agent that has finished its role, and transfers agent information to another node, thereby transferring the agent to another node. It is a means for accepting agents that move to other nodes and move similarly from other nodes. When a user wants to perform some information processing using such an agent system, the local node 800L generates an agent by giving an instruction from the input / output unit 803L to the agent management unit 804L.
[0005]
In the most basic example, the user gives a script from the input / output unit 803L to the generated agent. The script is an agent action program, and specifically describes the contents such as which node to move to and what processing to perform. As a more specific example of a script, for example, it moves to node A and sends a copy of file a to the user's node, then moves to node B and sends a copy of file b to the user's node ... Such a content can be considered. Then, the interpretation execution means 802 (L, R) provided in each node activates the agent by executing such a script, thereby realizing the desired information processing.
[0006]
In this case, agent information storage means 801 (L, R) provided in each node stores information necessary for the agent. The information necessary for the agent includes, for example, the above-mentioned script, variables necessary for interpreting and executing the script (called script variables), and information and files collected by the agent if necessary. In addition to instructions that can be executed on only one node, instructions written in the script of the agent include a movement instruction for moving the agent to another node. Interpretation execution means 802L sequentially executes the instructions of the script, and when it is necessary to execute the movement instruction, it designates the destination node and requests the agent management means 804 to move the agent.
[0007]
In such an agent system, when a user wants to collect some files from the network, the agent may have an action program for achieving this purpose and send it to the network. Act autonomously based on a given script. For this reason, there is no need to maintain communication between the user node and the agent, so there is an advantage that it is more resistant to line failures than conventional network functions such as ftp and telnet.
[0008]
[Configuration example using planning]
In contrast to the agent system shown in FIG. 7, there is also known an agent system that can change a script, which is an agent behavior program, according to the situation.
[0009]
In other words, as the network becomes larger and more complex as in recent years, especially when it becomes a so-called open network by connecting to a wide area network such as the Internet, the components of the network such as the location of files often change. To come. However, in the agent system as shown in FIG. 7, since the agent is given a fixed script at the time of generation, the action cannot be changed according to the situation. Therefore, in order to flexibly cope with such a change, the present applicant has applied for an agent system having a planning function as a technique for automatically changing an agent's behavior without bothering humans.
[0010]
In this technology, an agent's action program is called a plan, and generating a plan is called planning. In this technique, a plan is appropriately rewritten according to the situation to cope with changes in network components. Note that re-planning in response to changes in the network configuration or the like is called re-planning.
[0011]
An example of the configuration of such an agent system is shown in the functional block diagram of FIG. In this technique, information used for generating a plan includes information called “knowledge” and action definition. Of these, “knowledge” is various information used for agent operation, particularly for planning, and includes, as an example, information related to network components such as which file exists in which node. For example, in the example of FIG. 8, such knowledge about the network configuration is stored in the local information storage unit 1L, and when there is a change in the network configuration, the update unit 2L performs automatic detection, manual operation, etc. To reflect such changes in knowledge. The action definition is information indicating what kind of instruction (action) can be used as a part constituting the plan, and is stored in the agent information storage means 3.
[0012]
In such an agent system, a user who instructs generation of an agent gives a goal to be achieved to a node instead of a script. Here, the goal is a state in which a state desired to be achieved as an information processing purpose is described in a predetermined grammar. Then, the plan generation means 5 generates a plan for achieving the goal by combining various actions included in the action definition while referring to the given knowledge. In such an agent system, changes in the network configuration are reflected in the agent plan through knowledge during planning and replanning, so the agent responds to changes in the situation without human intervention, The behavior can be changed flexibly.
[0013]
The means for generating such a plan is also called a “planner”, and its entity is a kind of program that represents a planning procedure. The broad concept of calling an agent's action program and each part thereof is a script, and the term “plan” particularly refers to the entire script generated by the agent performing the planning as shown in FIG.
[0014]
[Example of planning]
Subsequently, FIG. 9 illustrates a specific operation procedure of the agent system using the above planning. In this procedure, when a user inputs a description (request description) for a request as an information processing goal (step 201), after necessary initialization is performed (step 202), a plan is generated (step 202). 203). The process ends according to the determination result of the end condition such that the goal has already been achieved (steps 204 and 205).
[0015]
That is, until such an end condition is satisfied, a plan that needs to be executed to achieve the goal is executed (step 204). In the execution of the plan, each instruction included in the plan is sequentially executed, and when the instruction to be executed is a movement instruction, a process for moving the agent between nodes (called a go action) is executed (steps 206 to 208). . If execution of each command or go action fails, a new plan is generated as necessary.
[0016]
Here, in the action definition used for generating the plan, a precondition and a postcondition are defined for each type of action (operation). Of these, the precondition represents what condition can be executed if the condition is satisfied, and the postcondition represents what condition is created when the operation is executed. For example, in order to perform an operation of “copying a file”, a precondition “a file exists on the current node” is necessary, and “a copy of the file exists” as a result of the copy operation. Post-conditions are produced.
[0017]
Plan generation executes a plan by continuing the process of discovering an action that produces a final goal as a postcondition and finding another action that produces a precondition of this action as a postcondition. To obtain a sequence of actions that connect between the previous state (current state) and the final goal. FIG. 10 is a diagram illustrating an example of a plan in the middle of generation. In this example, for one precondition C5 of the operation P2 and the precondition C7 of the operation P3, an operation that generates these preconditions as postconditions. Has not been found yet. Thus, a precondition for which no other action has yet to be generated as a postcondition is called an unachieved goal.
[0018]
Such a plan generation process is performed retroactively from the goal side and ends when the state (current state) that exists at the time of starting execution of the plan is reached. FIG. 11 is a diagram showing an example of a plan completed by such processing.
[0019]
Next, a specific procedure for generating a plan is shown in FIG. That is, in this procedure, a part of the goal list for recording goals is set as an unachieved goal list for recording unachieved goals as shown in FIG. 10, and the following processing is performed. First, until there are no unachieved goals in the goal list (step 401), unachieved goals are selected one by one from the unachieved goal list (step 402), except when the goals are satisfied (step 403). ) Perform the following operations. That is, if there is an action that can achieve the goal pre-condition by the post-condition (step 404), this action is selected (step 405), and the action thus selected (selected action) is as shown in FIG. Are added to a series of various operations (plan tree) (step 406).
[0020]
If there is no action that can achieve the goal, it is determined whether the goal can be achieved with uncertain knowledge. Here, the uncertain knowledge is knowledge about the configuration of the network whose specific value is not known unless some processing is actually performed at another node. If the goal can be achieved with uncertain knowledge, this uncertain knowledge is added as a selection operation to the plan tree (step 405). If the goal cannot be achieved even with uncertain knowledge, the process is backtracked (step 408). Then, the operation causing the current unachieved goal is replaced with another operation, and the process is performed again.
[0021]
For example, it is assumed that “file a exists in node A” in the node knowledge of the node used by the user. In this case, when the user gives the goal of obtaining the file a, the knowledge that it exists in the node A is referred, so the generated agent plan is “move to the node A and copy the file a Send to node ".
[0022]
However, if the file a is moved to the node B when the agent moves to the node A, the plan fails because the file a cannot be found, and replanning is performed on the node A. At this time, when the node knowledge of the node B is updated with the movement of the file and changed to “file a exists in node B”, the new plan is “moved to node B and moves to the file a. “Send a copy to the user's node”. As a result, the agent autonomously moves to the node B, and can safely find the file a and transmit it to the user's node.
[0023]
FIG. 13 shows a procedure when the agent moves between nodes based on the plan generated in this way. In this example, it is assumed that the agent moves from the local node where the user has generated the agent to a remote node that is another node. In this case, the remote node that has received the movement request (step 501) from the local node (step 502) sets up an agent process (step 503).
[0024]
Subsequently, the local node that has received the notification that the process setting has been completed (step 504) from the remote node (step 505), transmits agent information such as the agent plan and variable area to the remote node (step 506). ). The remote node that has received this agent information (step 507) stores the agent information (step 508), sends a notification of successful movement to the local node (step 509), and starts interpreting the plan (step 510). . On the other hand, the local node that has received the notification of success (step 511) deletes the process for the agent that is no longer necessary (step 512).
[0025]
[Agent life cycle]
Next, FIG. 14 is a conceptual diagram showing the life cycle of an agent who performs planning as described above. That is, when an agent is generated together with a goal input and starts an activity, it starts with a planning phase P for generating a plan, and in accordance with the generated plan, an execution phase E for executing the plan or a movement that moves between nodes. The phase shifts to the phase M, and the activity is performed while shifting between these phases according to the execution or movement failure. If the goal given initially is achieved, the process ends normally. If the goal cannot be achieved and the planning itself fails, the process ends with a complete failure.
[0026]
[Example using a farm]
An agent system in which several areas called “farms” are provided on one node is also conceivable. Here, the farm is an agent activity area set for each purpose and field of information processing, and is also called a field. A plurality of such farms (fields) can exist on one node, and information used for generating and executing resources such as memory and plans is provided for each farm (field).
[0027]
FIG. 15 is a conceptual diagram illustrating an example in which a plurality of hosts H (machines) are connected to the network N, one node X exists on each host H, and a plurality of fields FL exist on the node X. It is. In such an agent system, knowledge used for plan generation is divided for each farm (field FL), so that the agent does not need to refer to extra information when searching for information necessary for planning and the like. Therefore, information processing is made efficient. The knowledge used for plan generation can be divided into farm knowledge possessed by a farm, agent knowledge possessed by an agent, etc., depending on the subject possessing the knowledge.
[0028]
[Problems to be solved by the invention]
However, the conventional techniques as described above have the following problems.
(1) First, as described above, the agent system is a complex system that not only has a plurality of nodes but also a plurality of agents move around on these nodes. Conventionally, a monitor that displays a status for each individual node included in a network has been known. However, it manages what kind of nodes and agents exist in the entire agent system, grasps the agents that exist on specific nodes, and tracks how specific agents move on the nodes. The monitor was not known. For this reason, it is difficult to effectively manage the entire system by grasping the state of the entire system and the movement path of the agent, and debugging the information held by the node and the agent.
[0029]
(2) When the goal is given, the agent system generates a plan for achieving the goal based on knowledge and action definition. However, conventionally, there has been no tool for confirming whether a correct script is generated for a given goal. This makes it difficult to debug knowledge and action definitions.
[0030]
Also, a given goal usually derives one or more subgoals. This sub-goal is a goal created intermediately when generating a plan in order to achieve the final goal. For example, if two separate prerequisites are needed to achieve a final goal, each condition becomes a subgoal, and a partial script is generated to achieve each subgoal .
[0031]
Therefore, even if a text file can be extracted from the system for the entire script generated corresponding to the final goal, what kind of script is used to achieve the relationship between the goal and the subgoal and the subgoal? Is difficult to understand, and it is difficult to properly debug the desired part.
[0032]
(3) Since the conventional script simply executes the described instructions in order, it is relatively easy to grasp the operation. However, when the script becomes complicated, it is difficult to grasp the operation.
[0033]
That is, the applicant defines an action definition that indicates what instruction can be used under what condition, and a script entity that specifically describes what operation is performed as an operation of a certain instruction. We have applied for an agent system that can be described separately. In this agent system, the script body can be freely described without being restricted by the action definition description grammar. For this reason, complicated operations can be described in a script by using various control syntaxes and variables.
[0034]
When debugging such a complex script, it is indispensable to understand which part of the script is executed in what order, and which variable changes and how it changes accordingly. Conventionally, however, there has been no technology for debugging such a complex script, and it has been particularly difficult to debug a complex script.
[0035]
The present invention has been proposed in order to solve the above-described problems of the prior art, and an object thereof is to provide a technology that effectively supports management and development of an agent system. More specifically, the object of the present invention is as follows.
(1) To be able to grasp the behavior of the agent system by monitoring each unit such as the whole, nodes, and agents with a monitor.
(2) To provide a technology that effectively supports debugging of an agent system.
(3) To provide a technique for effectively debugging a complicated script.
[0036]
[Means for Solving the Problems]
  To achieve the above objectives,The monitoring apparatus according to the present invention includes a plurality of nodes connected to a network, and the plurality of nodes includes a local node that generates an agent and moves the node to another node, and a destination of the agent generated in the local node In the monitoring apparatus of the agent system that performs information processing while moving the agent from the local node to the remote node, either the node or a computer different from the node connected to the network Is provided with a system monitor for monitoring the entire agent system, each node is provided with a node monitor for monitoring the node, and an agent on the node is assigned to a node in which the agent exists. Agent to monitor A monitor is provided, and the node monitor holds an agent monitor that monitors an agent existing on the corresponding node, and when the agent moves to another node, discards the agent monitor, and is a node to which the agent is moved The node monitor that monitors the agent is configured to generate and hold an agent monitor that monitors the agent that has moved. Moreover, what grasped | ascertained the structure of the said monitor apparatus from the viewpoint of the method or a computer-readable recording medium is also 1 aspect of this invention.
According to the present invention having such a configuration, since the entire system, nodes, and agents can be monitored by dedicated monitors, the state of both the entire agent system and each part can be effectively grasped, and the agent system is managed. And debugging becomes easier. In particular, when an agent moves between nodes, the agent monitor of the moved agent is discarded at the source node and regenerated at the destination node, so there is no need to send the agent monitor with the agent, and such transmission This eliminates the time and effort required.
[0037]
According to another aspect of the present invention, a node monitor and an agent monitor are started from the system monitor, and an agent monitor is started from the node monitor. What kind of nodes and agents exist in the agent system Of a node monitor that monitors a specified node or an agent monitor that monitors a specified agent, and outputs to a system monitor window that is a display screen provided in the computer connected to the node or the network. The node monitor is configured to activate at least one of them, and the node monitor outputs to the node monitor window, which is a display screen provided in the node, what kind of agent exists in the corresponding node, and specifies Agent Characterized in that it is configured to start the agent monitor for viewing. In these aspects of the present invention, since other types of monitors can be activated from each monitor, it becomes easy to grasp the state of the agent system from various angles.
[0038]
According to still another aspect of the present invention, the node monitor is a node monitor window which is a display screen provided in the node to indicate what kind of log file in which the operation of the agent is recorded in the corresponding node. And the operation of the agent is confirmed based on the specified log file. According to this aspect, since the operation of the agent can be confirmed by reproduction or the like based on the log file of the desired agent, the operation of each agent can be easily considered.
[0039]
According to another aspect of the present invention, the agent monitor is configured to set a breakpoint at a desired portion of the corresponding agent plan, and the agent monitor is configured to select a desired portion of the corresponding agent plan. The part is characterized in that it is configured to set a logging point for controlling the log recording of the agent operation. According to such an aspect of the present invention, since a breakpoint can be set from the agent monitor to the agent, it is possible to easily shift from monitoring the state of the agent to debugging, and work efficiency is improved. In addition, by setting logging points in the agent plan, it is possible to easily record only the necessary parts.
[0047]
DETAILED DESCRIPTION OF THE INVENTION
Next, an embodiment of the present invention (hereinafter referred to as “embodiment”) will be described with reference to the drawings.
It should be noted that the present invention is generally realized by controlling a computer having a peripheral device with software. In this case, information can be input by an input device such as a keyboard and a mouse, and information can be output by an output device such as a CRT display device and a printer. In addition, storage devices such as registers, memories, and external storage devices can temporarily hold or permanently store information in various formats. Then, according to the software, the CPU can add processing such as processing and determination to these pieces of information, and further control the order of processing.
[0048]
The software for controlling the computer is created by combining instructions corresponding to the processing described in each claim and specification, and the created software is executed by a processing system such as a compiler or an interpreter. Utilize hardware resources as described above.
[0049]
However, the above-described aspects for realizing the present invention can be variously modified. For example, in order to input / output information between the apparatus of the present invention and the outside, a removable recording such as a floppy disk can be used. Media and network connection devices can also be used. Further, a recording medium such as a CD-ROM on which software for realizing the present invention is recorded is an embodiment of the present invention. Also, some of the functions of the present invention can be realized by a physical electronic circuit such as an LSI.
[0050]
As described above, since various aspects of implementing the present invention using a computer can be changed, embodiments of the present invention will be described below by using virtual circuit blocks that implement each function of the present invention. To do.
[0051]
[1. First Embodiment ... Monitor Device]
1st Embodiment respond | corresponds to Claims 1-14, The system monitor which monitors the whole system in the monitor apparatus for monitoring the agent system which an agent performs information processing while moving on a some node, A node monitor for monitoring the node and an agent monitor for monitoring the agent.
[0052]
[1-1. Constitution〕
FIG. 1 is a conceptual diagram showing the configuration of the first embodiment. As shown in this figure, the first embodiment includes a system monitor 111 that monitors the entire agent system, a node monitor 113 that monitors the node 112, and an agent monitor 115 that monitors the agent 114. Each of these monitors is started as a process executed on the node, for example.
[0053]
Of these, the system monitor 111 may be provided on any node connected to the network of the agent system. However, the system monitor 111 must be started up on any host (machine) other than the node that can be referred to by the agent system via the network. Is also possible. In this way, the system can be monitored from outside the agent system.
[0054]
In order to reduce the amount of communication with the naming system 119, it is desirable to provide the system monitor 111 on a host where the naming service 119 exists. The naming service (name server) 119 can also be started on any host other than the node that can be referred to by the agent system via the network.
[0055]
The node monitor 113 monitors a specific node, and the same number of node monitors 113 are started up and used for each node in order to monitor a plurality of nodes.
[0056]
The agent monitor 115 also monitors one specific agent, and the same number is used for a plurality of agents. This agent monitor is held as a part of the node monitor 113 by the node monitor 113 of the node where the corresponding agent exists.
[0057]
The system monitor 111, the node monitor 113, and the agent monitor 114 input / output data to / from the user via the system monitor window 116, the node monitor window 117, and the agent monitor window 118, which are corresponding display screens, respectively. And accepts instructions, operations, and various specifications. Each of these monitors 111, 113, and 115 can be directly started individually by the user, or other monitors can be activated with each other.
[0058]
Here, the node monitor 113 is preferably provided on a node to be monitored in terms of the ease of collecting node information, and the information collected by the node monitor 113 is a node monitor window 117 which is a display screen. And an instruction from the user is also given through the node monitor window 117.
[0059]
The node monitor window 117 is mainly responsible for communication between the node monitor 113 located in a remote place and the user. Therefore, as a normal configuration example when monitoring a node from a remote place in this way, the node monitor 113 exists on the node, and the node monitor window 117 is started on the user side machine that monitors this node. The form is considered. Each of the monitoring windows 116 to 118 can be started on an arbitrary host that can be referred to by the agent system via the network.
[0060]
[1-2. Action)
The first embodiment having the above configuration has the following operation. Here, FIG. 2 is a flowchart showing a processing procedure in the first embodiment.
[1-2-1. System monitor operation)
First, when the user first starts up the system monitor 111 (step 6211), the system monitor 111 acquires information on the entire system by communicating with the naming service 119 of the agent system, and displays the acquired information on the display screen. It is displayed on a certain system monitor window 116 (step 6212). The information displayed by the system monitor 111 in this way is specifically a list of what nodes and agents exist in the agent system, for example.
[0061]
By specifying a desired node from this list (step 6213), the user can start (start up) the node monitor 113 that monitors the node (step 6221). Similarly, the user can start an agent monitor 115 that monitors the agent by designating the agent from the list (step 6214) (step 6231). In order to specify a node or an agent, for example, the name can be typed from the keyboard, or the node name or agent name on the list can be double-clicked with the mouse.
[0062]
[1-2-2. Action of node monitor
When the node monitor 113 is started up (step 6221), the node monitor 113 acquires information related to the node 112 by communicating with the corresponding node 112, and displays the acquired information on the node monitor window 117 which is a display screen (step 6222). . The information displayed by the node monitor 113 in this way includes, for example, a list of what agents 114 exist in the corresponding node 112 and an agent log file (hereinafter simply referred to as “log”) remaining in the node 112. ) List.
[0063]
Here, the log is information that records how a specific agent behaves based on the plan for each step of the instructions included in the plan. On the display screen of the node monitor 113, the user can start the agent monitor 115 that monitors the agent by designating a desired agent name by double clicking with the mouse (step 6223) (step 6231). ).
[0064]
Further, the user can confirm the operation of the agent based on the log by designating a desired log on the display screen of the node monitor (step 6224). Specifically, an agent is generated based on the log, and the agent can behave as it is recorded in the log, or the subsequent operation can be continued.
[0065]
[1-2-3. Agent Monitor Action)
The agent monitor 115 acquires information about the agent by communicating with the corresponding agent, and displays the acquired information on the agent monitor window 118 which is a display screen (steps 6232 and 6233). The information displayed by the agent monitor 115 includes, for example, which node the agent is in (step 6232) and an execution state (step 6233) indicating which part of the current plan the agent is executing.
[0066]
[1-2-4. (Breakpoint setting)
The agent monitor 115 has a function of controlling the operation of the agent, and the user sets a breakpoint at a desired part of the agent plan using the agent monitor 115 (step 6234). Execution can be stopped, each instruction included in the plan can be executed one step at a time from the position where it was stopped, or the next breakpoint can be executed.
[0067]
Various types of breakpoints can be set depending on the conditions under which the plan execution is stopped. In addition, for a target to be provided with a breakpoint, for example, a specific line in the plan may be used as a unit, a specific command may be used as a unit, or a specific goal or subgoal may be used as a unit. Furthermore, the types of breakpoints and the setting targets as described above can be freely combined. The breakpoint set in this way is displayed on an agent monitor window 118 that is a display screen of the agent monitor 115.
[0068]
[1-2-5. (Logging point setting)
Further, the user can set a logging point at a desired portion of the corresponding agent plan using the agent monitor 115 in the same manner as a breakpoint. Here, the logging point is a point for controlling the log recording of the agent operation, and is used for designating a start point and an end point for log recording. Similarly to the breakpoint, the logging point can be set by combining various conditions and target units. For example, it is possible to specify not only the range where the log is recorded when executing from where in the plan, but also the condition for recording the log, for example, recording only during the recovery process for the execution failure.
[0069]
When the agent plan is executed, the agent monitor 115 records the agent log file for the condition and target specified by the logging point, and outputs them to the agent monitor window 118 according to the user's request. Further, by using the log file obtained in this way from the node monitor 113, the agent is reproduced in the same state as when the log is taken, and the operation recorded in the log is reproduced, or the destination. The execution of the operation can be continued.
[0070]
[1-2-6. (Process when agent moves)
By the way, when an agent supported by the agent monitor 115 moves to another node (FIG. 3), the node monitor 113 holding the agent monitor 115 discards the agent monitor 115 and moves the agent movement destination. An agent monitor 115 is newly generated in the node monitor 113 corresponding to the node.
[0071]
Even if the agent monitor 115 moves in this way, it is necessary to use the same agent monitor window 118 as a display screen for the user. Therefore, when the agent monitor 115 is discarded due to the movement of the agent, as shown in FIG. 3, the agent monitor window 118 displays on which system monitor 111 the agent monitor 115 corresponding to the same agent is newly generated. Contact The agent monitor window 118 establishes a data link with the newly generated agent monitor 115 based on the answer from the system monitor 111 and displays information sent from the agent monitor 115. The process of transferring the instruction from the user to the agent monitor 115 is continued.
[0072]
[1-3. effect〕
As described above, in the first embodiment, since the entire system, nodes, and agents can be monitored by dedicated monitors, the state of both the entire agent system and each part can be effectively grasped, and management of the agent system Debugging is easy. In particular, in the first embodiment, since other types of monitors can be activated from each monitor, it becomes easy to grasp the state of the agent system from various angles.
[0073]
Further, in the first embodiment, since the operation of the agent can be confirmed by reproduction or the like based on the log file of the desired agent, the operation of each agent can be easily considered. In the first embodiment, when an agent moves between nodes, the agent monitor of the moved agent is discarded at the source node and regenerated at the destination node. Therefore, it is necessary to transmit the agent monitor together with the agent. Therefore, the time and effort required for such transmission are not required.
[0074]
Further, in the first embodiment, it is possible to output which node the agent is in and which part of the plan is executed, so that it is easy to grasp the state of the desired agent. In the first embodiment, since a breakpoint can be set from the agent monitor to the agent, it is possible to easily shift from monitoring of the agent state to debugging, and work efficiency is improved. Further, in the first embodiment, by setting a logging point in the agent plan, it is possible to easily record only a necessary part of the log.
[0075]
[2. Second Embodiment ... Debugging Device]
The second embodiment corresponds to claims 15 to 21 and is a debugging device for debugging an agent system. In the agent system to be debugged by the debugging device, the planner generates an agent plan based on knowledge and action definition, and the agent performs information processing by executing the generated plan.
[0076]
In the second embodiment, the knowledge, action definition, and planner used in such an agent system are examined by checking whether the plan script generated when they are used is correct. It is for debugging the planner. The entire action program executed by the agent is a plan, that is, a script, and the planner is a program that performs a procedure for generating a plan (script) by referring to knowledge and action definitions as data necessary for generating the plan, that is, the script. is there.
[0077]
[2-1. Constitution〕
First, FIG. 4 is a functional block diagram showing the configuration of the second embodiment. As shown in this figure, the second embodiment has a knowledge debugger D and a script tracer T. The knowledge debugger D is means for generating a script S1 for achieving a given goal by using knowledge, action definition, and planner designated as debug targets. The script tracer T is a means for examining the behavior of a given script.
[0078]
Among these, the knowledge debugger D controls the first setting means D1 for setting the debug target, the generation means D2 for generating a script based on the set debug target, and the display of the generated script. Display control means D3.
[0079]
The script tracer T includes a second setting unit T1, an execution control unit T2, and an output control unit T3. Among these, the second setting means T1 is a means for setting a breakpoint for a given script and designating a variable to be monitored. Further, the execution control means T2 is a means for executing a given script in a designated manner, and as such an execution manner, for example, whether to execute one step at a time or to execute all at once can be selected. The execution control means T2 is configured to stop execution of the script at the breakpoint. The output control means T3 is a means for outputting information obtained by executing the script, for example, the value of a designated variable.
[0080]
[2-2. Action)
FIG. 5 shows a debugging procedure using the second embodiment as described above. In the second embodiment, the user can make various settings, give instructions, and refer to information using a GUI (graphical user interface).
[0081]
[2-2-1. (Specify debug target)
First, the user makes necessary edits or modifications to the knowledge, action, and planner to be debugged using a conventional editor or the like (step 7201). Subsequently, the knowledge, action, and planner to be debugged are specified using the first setting means D1 of the knowledge debugger D (step 7202). Specifically, for example, when knowledge, action definitions, and planners can be selected and used from a plurality of candidates, these candidates are displayed on an input / output display screen (dialog), and are used as debugging targets from among them. Select an action definition or planner. It is also possible to specify a target information file as necessary, and read information from the file for debugging. These pieces of selected information are displayed in a predetermined text display field (text box).
[0082]
[2-2-2. (Generate script)
After selecting information to be debugged as described above, the user inputs and sets a desired goal from the dialog. Subsequently, the generation means D2 is activated by clicking a predetermined operation, for example, a GetScript button graphically displayed on the display screen with a mouse. The activated generation means D2 generates a script for achieving the given goal using the selected knowledge, action definition and planner (step 7203), and the generated script is used for predetermined display. Output to the window.
[0083]
[2-2-3. (Subgoal extraction)
The display control means D3 controls how to display the script generated in this way. That is, first, the display control means D3 extracts subgoals included in the generated script (step 7204) and displays them as a subgoal list in a display window different from the script itself. Such a subgoal is expressed using a predetermined command word in the script, for example, subgoal or newgoal. Therefore, in order to extract a subgoal, these command words may be searched from the script. By selecting a desired subgoal G from the subgoals extracted and displayed in this manner (FIG. 4), only a partial script S2 for achieving the subgoal G is generated and output. You can also.
[0084]
[2-2-4. (Hierarchical display of scripts)
Further, the display control means D3 can display the goal and the subgoal, the script corresponding to the goal and the partial script corresponding to the subgoal based on the hierarchical relationship (step 7205). In other words, the relationship between the final goal and the subgoal has a hierarchical relationship in which the final goal is higher and each subgoal for achieving the final subgoal is lower. Therefore, the subscripts corresponding to the lower subgoals and the subgoals are hierarchically managed and displayed in relation to the entire script.
[0085]
For example, after expanding a subgoal into a specific script and displaying it, clicking the Up button to return the display to a higher hierarchy with the mouse will display the entire upper script that contains the expanded subgoal, or this overall You can also go back to the final goal output screen for the correct script. Similarly, when the subgoal script includes a lower subgoal, the lower scripts can be expanded and displayed in a hierarchical manner, or conversely, the screen can be returned to the upper display screen sequentially.
[0086]
Here, a state in which a partial script corresponding to the subgoal in the script is displayed and lower information is displayed based on the subgoal in the displayed script is shown in the conceptual diagram of FIG. If a bug is found as a result of displaying the script in this way (step 7206), it is sufficient to return to the edit / correction of the debug target (step 7201) and start again.
[0087]
[2-2-5. Script trace]
Further, by passing the desired script obtained as described above to the script tracer T, the script can be traced. When tracing the script, the user clicks the Trace button on the display screen with the mouse while the script to be traced is selected by, for example, reverse display. Then, the script tracer T is activated (step 7207), an input / output window for the script tracer T appears, and the passed script is displayed as text.
[0088]
[2-2-6. (Setting breakpoints and variable watch expressions)
On the text display screen, the user can set break points at any desired position using the second setting means T1 (step 7208). In addition, the user uses the second setting means T1 to specify a desired variable among variables used in the script by using a variable watch expression (step 7208). Here, the variable watch expression is an expression that specifies which variable is monitored when the script is executed, and what kind of change is presented to the user when that variable is changed. It is.
[0089]
With such a variable watch expression, for example, a warning can be displayed when the values of two variables are inconsistent, or a specified range of bits within a variable can be displayed in a sequence of 1s and 0s. It can be carried out. Such display specified by the variable watch expression is realized by the output control means T3.
[0090]
[2-2-7. (Run script)
The script in which breakpoints and variable watch expressions are set as described above is executed by the execution control means T2 (step 7209). At this time, the user can execute the script step by step using the execution control means T2, or can execute each step continuously. When executing such a script, the output control means T3 sequentially displays and records the contents of the variable designated by the variable watch expression.
[0091]
Even when each step is executed continuously, the execution control means T2 stops execution at the set breakpoint (step 7209), so the user confirms what the value of each variable is at that time. (Step 7210). Further, when executing one step at a time, it is possible to examine in detail which part of the script is executed in what order and how the value of each variable changes. Also in this case, if a bug is found as a result of confirming the state of the script being executed or the contents of the variable, the work can be started again from editing / correction of the debug target (step 7201).
[0092]
[2-3. effect〕
As described above, in the second embodiment, a script for achieving a given goal is generated and output using a specified debug target, so that the user can perform a desired debug target as intended. You can easily check whether a script has been generated.
[0093]
In the second embodiment, not only the entire script corresponding to the final goal is displayed to determine whether it is correct, but also a partial script corresponding to the desired subgoal can be displayed for detailed examination. , Make the script easier to understand. Further, in the second embodiment, by displaying the goal and subgoal, the script corresponding to the goal and the partial script corresponding to the subgoal based on the hierarchical relationship such as switching between the display of the upper hierarchy and the display of the lower hierarchy, The desired range can be easily confirmed.
[0094]
In the second embodiment, script execution stops at a specified breakpoint, and execution of the script can be freely controlled in a desired manner such as executing step by step or executing to the next breakpoint. Also, since the contents of the specified variable can be examined, it is possible to effectively debug even a complex script.
[0095]
[3. Other Embodiments]
In addition, this invention is not limited to the said embodiment, Other embodiments which are illustrated next are included. For example, in the present invention, the scale, format, number of nodes, etc. of the network can be freely selected, and the type of information processing performed using the agent and the language format for describing the action definition, knowledge, plan, etc. can be freely selected. .
[0096]
In the first embodiment, the specific configurations and information display formats of the system monitor, the node monitor, and the agent monitor are arbitrary, and these monitors and the display screens of the monitors can be configured integrally. Also, a function for starting other monitors from each monitor, a function for handling log files, and a function for setting breakpoints and logging points from the agent monitor are not necessarily required. When the agent moves to another node, it is not always necessary to discard the agent monitor, and the agent monitor may be transferred to the destination together with the agent.
[0097]
Further, in the second embodiment, it is not necessary to limit the debugging target to knowledge, action definition, and planner, and other desired components can be added according to the system configuration. Also, it is not necessary for the user to select all debug targets, and the standard configuration (default) on the system can be selected for targets that are not selected. Further, when the generated script is displayed, the display need not necessarily be hierarchical, and a means for setting a breakpoint in the generated script or executing it in a specified manner is not essential.
[0098]
【The invention's effect】
As described above, according to the present invention, since the behavior of the agent system can be grasped by monitoring each unit, such as the node, the agent, and the like, the management and development of the agent system can be effectively supported. .
[Brief description of the drawings]
FIG. 1 is a functional block diagram showing a configuration of a first embodiment of the present invention.
FIG. 2 is a flowchart showing a processing procedure in the first embodiment of the present invention.
FIG. 3 is a conceptual diagram showing processing when an agent moves between nodes in the first embodiment of the present invention.
FIG. 4 is a functional block diagram showing a configuration of a second embodiment of the present invention.
FIG. 5 is a flowchart showing a processing procedure in the second embodiment of the present invention.
FIG. 6 is a view for explaining hierarchical display in the second embodiment of the present invention.
FIG. 7 is a flowchart showing a configuration example of a conventional agent system.
FIG. 8 is a flowchart showing a configuration example of a conventional agent system that performs planning.
FIG. 9 is a flowchart showing a processing procedure in a conventional agent system.
FIG. 10 is a conceptual diagram showing an example of a plan being generated in the agent system.
FIG. 11 is a conceptual diagram showing an example of a completed plan in the agent system.
FIG. 12 is a flowchart showing a planning procedure in the agent system.
FIG. 13 is a flowchart showing a procedure for moving an agent between nodes in the agent system.
FIG. 14 is a conceptual diagram showing the life cycle of an agent in the agent system.
FIG. 15 is a conceptual diagram showing a state in which a plurality of farms (fields) exist on a node in an agent system.
[Explanation of symbols]
1 ... Local information storage means
2 ... Update means
3 ... Agent information storage means
4 ... Input / output means
5 ... Plan generation means
6. Plan execution means
7 ... Agent Management Department
L ... Local machine
R ... Remote machine
N ... Network
111 ... System monitor
112 ... Node
113 ... Node monitor
114 ... Agent
115 ... Agent monitor
116 ... System monitor window
117 ... Node monitor window
118 ... Agent monitor window
119 ... Naming service
D ... Knowledge Debugger
D1 ... Target setting means
D2 ... Generation means
D3: Display control means
T ... Script tracer
T1 ... second setting means
T2: Execution control means
T3: Output control means
S1, S2 ... Script
C ... Condition
P ... operation
S ... State
800N ... Network
800L ... Local node
800R ... Remote node
801: Agent information storage means
802 ... Interpretation execution means
803 ... Input / output means
804 ... Agent management means
STEP ... Procedure steps

Claims (13)

A plurality of nodes connected to a network are provided, and the plurality of nodes are provided with a local node that generates an agent and moves it to another node, and a remote node that is a destination of the agent generated at the local node. In the monitor device of the agent system that performs information processing while moving the agent from the local node to the remote node,
Either a computer other than the node or the node connected to the network is provided with a system monitor for monitoring the entire agent system, and each node is provided with a node monitor for monitoring the node, In each node, an agent monitor that monitors an agent on the node is provided for the node where the agent exists,
The node monitor holds an agent monitor that monitors an agent existing on a corresponding node, and when the agent moves to another node, discards the agent monitor and monitors a node to which the agent is moved The node monitor is configured to generate and hold an agent monitor that monitors an agent that has moved.   The agent monitor according to claim 1, wherein a node monitor and an agent monitor are activated from the system monitor, and an agent monitor is activated from the node monitor.   The system monitor outputs to a system monitor window, which is a display screen provided in a computer connected to the node or network, what kind of nodes and agents exist in the agent system, and is designated. 3. The agent system monitoring device according to claim 1, wherein at least one of a node monitor for monitoring a node and an agent monitor for monitoring a specified agent is activated.   The node monitor outputs what kind of agent exists in the corresponding node to a node monitor window which is a display screen provided in the node, and starts the agent monitor that monitors the specified agent. 4. The agent system monitoring device according to claim 1, wherein the agent system monitoring device is configured.   The node monitor outputs to the node monitor window, which is a display screen provided in the node, what kind of log file in which the operation of the agent is recorded in the corresponding node, and the designated log file The agent system monitoring apparatus according to claim 1, wherein the agent system is configured to confirm the operation of the agent based on the agent.   The agent monitor outputs to the agent monitor window provided in the node where the agent monitor is activated, which node the corresponding agent is on and which part of the plan the agent is currently executing. 6. The agent system monitoring device according to claim 1, wherein the agent system monitoring device is configured.   7. The agent system monitoring apparatus according to claim 1, wherein the agent monitor is configured to set a breakpoint at a desired portion of a corresponding agent plan.   8. The agent monitor according to claim 1, wherein the agent monitor is configured to set a logging point for controlling log recording of an agent operation in a desired portion of a corresponding agent plan. The agent system monitoring device according to any one of the above. A plurality of nodes connected to a network are provided, and the plurality of nodes are provided with a local node that generates an agent and moves it to another node, and a remote node that is a destination of the agent generated at the local node. In the monitoring method of the agent system that performs information processing while moving the agent from the local node to the remote node,
Either a computer other than the node or the node connected to the network is provided with a system monitor for monitoring the entire agent system, and each node is provided with a node monitor for monitoring the node, Using the monitor device provided with the agent monitor that monitors the agent on the node in the node where the agent exists in each node,
Causing the node monitor that generates and moves the agent to retain an agent monitor that monitors an agent existing on the corresponding node; and discards the agent monitor when the agent moves to another node. ,
A method for monitoring an agent system, comprising: causing a node monitor that monitors a node to which the agent is to move to generate and retain an agent monitor that monitors a moved agent.   The system monitor that monitors the entire agent system outputs what kind of nodes and agents are present in the agent system to a system monitor window that is a display screen provided in the computer connected to the node or network. 10. The agent system according to claim 9, further comprising: a step of specifying at least one of a node or an agent, and a step of starting at least one of the node monitor or the agent monitor. Monitoring method.   The node monitor outputs, to a node monitor window, which is a display screen provided in the node, what kind of agent exists in the corresponding node, a step for designating an agent, and the agent monitor 11. The agent system monitoring method according to claim 9 or 10, wherein the step of activating is executed.   The agent monitor outputs to the agent monitor window provided in the node where the agent monitor is activated, which node the corresponding agent is on and which part of the plan the agent is currently executing. The agent system monitoring method according to claim 9, wherein the agent system monitoring method is executed. A plurality of nodes connected to a network are provided, and the plurality of nodes are provided with a local node that generates an agent and moves it to another node, and a remote node that is a destination of the agent generated at the local node. A computer-readable recording medium recording a computer program for realizing an agent system that performs information processing while moving an agent from a local node to a remote node,
The program includes a system monitor for monitoring the entire agent system on either the node or a computer different from the node connected to the network, a node monitor for monitoring the node for each node, A node having an agent among the nodes realizes a monitor device having an agent monitor for monitoring the agent on the node ,
Causing the node monitor that generates and moves the agent to retain an agent monitor that monitors an agent existing on the corresponding node; and discards the agent monitor when the agent moves to another node. ,
A monitoring program for an agent system is recorded, which causes a node monitor that monitors a node to which the agent is moved to execute a step of generating and holding an agent monitor that monitors an agent that has moved Computer-readable recording medium.

Images