WO2001037064A2 - Phase d'interpretation pour architecture logicielle orientee agent adaptatif - Google Patents

Phase d'interpretation pour architecture logicielle orientee agent adaptatif Download PDF

Info

Publication number
WO2001037064A2
WO2001037064A2 PCT/US2000/041910 US0041910W WO0137064A2 WO 2001037064 A2 WO2001037064 A2 WO 2001037064A2 US 0041910 W US0041910 W US 0041910W WO 0137064 A2 WO0137064 A2 WO 0137064A2
Authority
WO
WIPO (PCT)
Prior art keywords
agent
agents
responsibility
subject message
queried
Prior art date
Application number
PCT/US2000/041910
Other languages
English (en)
Other versions
WO2001037064A3 (fr
Inventor
Babak Hodjat
Original Assignee
Dejima Inc.
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Dejima Inc. filed Critical Dejima Inc.
Priority to AU27510/01A priority Critical patent/AU2751001A/en
Publication of WO2001037064A2 publication Critical patent/WO2001037064A2/fr
Publication of WO2001037064A3 publication Critical patent/WO2001037064A3/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
    • G06N5/00—Computing arrangements using knowledge-based models
    • G06N5/04—Inference or reasoning models
    • G06N5/043—Distributed expert systems; Blackboards
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/54—Interprogram communication
    • G06F9/546—Message passing systems or structures, e.g. queues

Definitions

  • the invention relates to software methods and techniques for implementing an agent-oriented architecture, and more particularly to techniques for improving the interpretation phase in such an architecture.
  • KQML 1993 KQML Agent-Communication Language
  • Each queried agent recursively determines whether it has an interpretation policy of its own that applies to the request, and if not, further queries its own further downchain neighboring agents.
  • the further agents eventually respond to such further queries, thereby allowing the first-queried agents to respond to the initiator agent.
  • the recursive invocation of this procedure ultimately determines a path, or a set of paths, through the network from the initiator agent to one or more leaf agents.
  • the network is often able to resolve many of such contradictions according to predetermined automatic algorithms. If it cannot resolve a contradiction automatically, it learns new interpretation policies necessary to interpret the subject message properly.
  • Such learning can include interaction with a user, and can be designed to localize the learning as closely upchain to the correct leaf agent in the network as possible.
  • the request is then transmitted down each determined path, with each agent along the way taking any local action thereon and passing the message on to the next agent in the path.
  • queried agents respond at a fixed time after receipt of a query, whether or not they have received all responses from their own downchain agents.
  • a queried agent makes claims to its upchain inquiring agent upon receipt of each claim that the queried agent receives from its own downchain agents.
  • a queried agent can receive a particular query more than once, and in response to each, the agent responds with whatever claims it then has. Other variations are also possible, as well as combinations of these and other variations.
  • the agent originating a query can send a "forget-problem" message down into the network after some period of time.
  • the originating agent can include a "depth-of-search" indication with each query, thereby preventing propagation of the query through more than the indicated number of agents.
  • the originating agent can subsequently make the same query to the same downchain agents, but with an increased depth- of-search indication, if for example the originating agent is not yet satisfied with the claims it received in response to the first query.
  • Fig. 1 shows an example of a third-order interaction graph of a hyperstructure.
  • Fig. 2 illustrates a division of functions within an agent according to the invention.
  • Fig. 3a illustrates a 7-segment display and a numbering of its segments.
  • Fig. 3b illustrates a non-modular centralized solution for the 7-segment display example.
  • Figs. 3c and 3d illustrate alternative agent networks implementing the 7- segment display function.
  • Fig.4 illustrates an agent network implementing the logical NOR function.
  • Fig. 5 illustrates an agent network hyperstructure for parsing the grammar of example 1.
  • Fig. 7 illustrates an AAOSA hyperstructure for parsing a grammar.
  • Fig. 8 illustrates a parallel algorithm for an agent.
  • Fig. 9 illustrates an agent network hyperstructure for the robot servant example.
  • Fig. 6 illustrates a detail of part of the hyperstructure of Fig. 9.
  • Agent abstraction is a natural extension of object-oriented technology, encapsulating the agent's knowledge within an active process and providing a standard interface for communication.
  • Agent abstraction is a natural extension of object-oriented technology, encapsulating the agent's knowledge within an active process and providing a standard interface for communication.
  • the concept of large ensembles of semi- autonomous intelligent agents working together is emerging as an important model for building the next generation of sophisticated software applications.
  • AAOSA Adaptive Agent Oriented Software Architecture
  • AAOSA Agents The goal of AAOSA is to provide software designers with the necessary coordination amongst AAOSA agents representing sub-domains of the software being developed in order to better meet the needs of the entire application. This coordination is provided through predefined messaging schemes between AAOSA agents.
  • Fig.2 illustrates an agent having a white box and a black box and illustrates some of the functions included in each.
  • AAOSA being object oriented in design, allows the black box to override, inherit from, or change any module in the white box (i.e., the data structures and methods in the white box are inherited within the black box, which can therefore access and modify them). Bass has shown that a problem is covered by a hyper-structure of computing elements. Fig.
  • Circles represent first order hyper-structures or computing modules of the lowest complexity in the given domain.
  • AAOSA agents The designer of an AAOSA application will:
  • AAOSA Agents • Break down the software to its manageable sub-domain elements (i.e., AAOSA Agents), • Define which agents will be in direct communication with each other.
  • Devise interpretation policies for each agent by considering the input to the application from each agent's point of view to decide if this agent is responsible for processing all or parts of this input.
  • An agent claims a particular input if it, or one or a number of agents down-chain to it are responsible for processing that input. In other words an agent claiming an input would, upon delegation, either process that input, or delegate it down-chain to one or a number of agents that had in turn claimed that input, or both.
  • AAOSA through predefined communication schemes, should pin point the agent or agents in this hyper-structure that are responsible for processing a certain input, and provide the necessary coordination between them in order to achieve desired output. Our hope is that in this way the designer will have to deal mostly with the breaking up and design of the software elements themselves rather than the complexities of how to coordinate them. Therefore another important difference between AAOSA agents and objects in the Object Oriented methodology is that an agent does not have to know which agents are responsible for a certain process or data structure, or that process' invocation details.
  • each software module By taking each software module to be an agent we can take advantage of a number of desirable features which we will impose on the designer as definitions of AAOSA agents: Each agent should be independent of the others and the only means of communication is messaging, handled by the white-box. This will provide for the possibility of parallel, distributed, and even mobile modules. Agents can be processing several requests at the same time.
  • AAOSA agents No centralized control is enforced over the resulting network of AAOSA agents covering the scope of a software application.
  • agents introduce themselves and their abilities to one another at the beginning or during execution. Agents can therefore be added to or removed from the application at runtime. This is one of the major differences between AAOSA and its precursor the Open Agent Architecture.
  • ARCHON Alternative for Cooperative
  • each agent i.e., the white box
  • the designer defined portion i.e., the black box
  • AAOSA agents are not centralized human-like agents with potentially conflicting intentions working together. Rather they are distributed software-obj ect-like agents designed to work together cooperatively to implement complex applications.
  • Processing of the input is done in two main phases: an interpretation phase, in which the agent, or agents responsible for actuating an input are located, and a delegation phase in which the processes that have been located are called.
  • Each AAOSA agent must be able to interpret input sent to it as the content field of messages from other agents if so requested in the performative field of that message (Table 1). The result of this interpretation may cause the agent to claim that input as its own and/or to declare certain other agent/s responsible for processing it. Agents may consult other agents in order to complete their claims. These latter agents we will call down-chain agents relative to the requesting agent. This is a relative term and depending on the direction of the flow of requests, an agent may be down-chain (receiving) or up-chain (requesting) with respect to another agent.
  • Agents that are first to receive input to the AAOSA system are called input agents. These agents initiate the interpretation phase for that input and are the entry points to the system, generating unique query IDs for new input. This does not mean that other agents do not query input agents. Cycles are prevented by preventing the agents from repeating processes already executed over the same query. Input agents are also responsible for announcing the end of the processing of a specific query to all down-chain agents.
  • Input may also have been generated inside the system and therefore any agent could potentially be an input agent.
  • a claim means all of input belongs to the agent making the claim.
  • a claim should contain other information as well (e.g., confidence in claim, name of claiming agent or symbol representing various claims one agent can make, the level of the claiming agent relative to the input agent of this query, parts of input that is being claimed).
  • the software designer is responsible for providing each agent with its interpretation policy.
  • An interpretation policy is comprised of a set of rules used to decide to return a claim that a piece of the input belongs to that particular agent.
  • the interpretation criterion may be the message content but is not limited to it.
  • the performer module in the white box actuates other modules in the agent based on the message performatives received from other agents.
  • Each message includes a message content, and a performative that specifies what should be done with that content. No overall standard data representation is needed for the message content.
  • Agent specific data can be transferred in messages in whatever format the sender and receiver agree upon. The designer can add agent-specific performatives in sub-domains to facilitate special communications between agents.
  • AAOSA provides a set of predefined general performatives by which the coordination of agents is managed (Table 2).
  • each agent upon receiving input with an "Is- This-Yours?" performative, attempts to inte ⁇ ret the input by itself. If inte ⁇ retation is successful, the agent will report claims using the "It-Is-Mine" performative. As we shall see, this does not always mean that this agent will be assigned to do its processing of the input.
  • an agent can not inte ⁇ ret the input as its own, before reporting failure, it must check with other down-chain agents. If all down-chain agents report "Not-Mine”, this agent will also report “Not-Mine” to its requesting agent. If at least one down-chain agent is able to inte ⁇ ret the input successfully and reports back with "It-Is-Mine", our agent will also report success. It follows that agents that have no down-chain agents to query may report "Not-Mine " upon failure to find an inte ⁇ retation policy that applies to the contents of the query message they have received. To prevent agents from repeatedly processing the same queries in a cycle, each agent keeps track of queries it has processed and will reply "Not-Mine " to any query it has already responded to and has no new claims for.
  • the delegation phase can start.
  • the "This-Is-Yours" performative is used to call agents on these paths to do the actual processing.
  • Agents receiving a "This-Is- Yours" request may reinte ⁇ ret the delegated input, or they may use pre-stored inte ⁇ retation or down-chain query results to, in turn, process or delegate (or both) the input or parts of it.
  • Ambiguities of which agent owns a particular piece of input, and methods for resolving them, are central to the proper operation of AAOSA. Ambiguities occur when an agent that a job has been delegated to (i.e., has received a message with the This-Is-Yours performative) has not been able to inte ⁇ ret the message content as belonging to it based on it's inte ⁇ retation policies, and
  • An ambiguity can be resolved by explicit interaction with another agent (e.g., an agent representing the human user). This is not always desirable or possible and therefore implicit resolution methods must be used.
  • Table 3 describes methods that can be used to resolve ambiguities in AAOSA. The choice of ambiguity resolution methods and the way they are combined to achieve best results depend on the application in which they will be used. Table 3) Ambiguity resolution methods.
  • Ambiguity and its resolution is particularly important in AAOSA because it provides a means by which agents can change their behavior (i.e., learn) and react to unexpected input.
  • an agent that does not have a suitable inte ⁇ retation for input contents of a message sent to it with the "Is-This-Yours?" performative will propagate this message to it's down-chain agents.
  • suitable inte ⁇ retation we imply that in cases where the inte ⁇ retation policy uses a small part of the whole input as its decision making focus, the agent may decide to query down-chain agents on the remainder of the input anyway, so as to make more accurate claims. In other words, agents complete their claims after receiving the results of their queries to their respective down-chain agents.
  • AAOSA When do we decide to abandon a query or stop propagating it down-chain?
  • the AAOSA design methodology is essentially a bottom-up approach: The tasks necessary to achieve overall goals are identified and suitably decomposed. Then the data-flow between these tasks is determined. This way, pre-existing code can also be inco ⁇ orated in the design as non-decomposable tasks by wrapping them into the black-box of AAOSA agents.
  • inte ⁇ retation policies The break up of software into sub-domains is the responsibility of the designer who should also define the inte ⁇ retation policies. This is done by looking at the system input from each agent's point of view. It is important not to over-generalize to avoid claiming input that really belongs to other agents. But there is no need to be too conservative either. Designers should keep in mind that inte ⁇ retations are done in the context of the communication path by which the input has arrived to the agent and resolving ambiguities that arise as a result of overlapping inte ⁇ retations are the responsibility of up-chain agents.
  • Figs. 3a-3d sometimes collectively referred to herein as Fig. 3.
  • the system to be designed takes a number between 0 and 9 and switches on the appropriate LEDs in a seven- segment display.
  • Fig. 3a illustrates the display and the numbering of its segments.
  • the first step in the design of this system would be to identify the range of possible input to the system and the set of output functions available. In this case, there are 10 possible inputs namely the numbers 0 to 9. There are 7 functions which should be used to produce the overall desired output: Switch LED 1 on (or On(l) for short), On(2), On(3)... On(7) on.
  • Fig. 3b illustrates a non-modular centralized solution, which involves 48 functions and 5.5 condition checks on average assuming each number is inputted with equal probability (1/10).
  • An alternative to this approach would be to have an agent represent each function and an input agent to receive the input and distribute it.
  • Such an agent network is illustrated in Fig. 3c. If the input-agent were to have any inte ⁇ retations of its own, they would be of the transitive kind, declaring an input to belong to one of the down-chain agents. However, in this example, transitive inte ⁇ retations are not necessary because the fact that input has been handed down through the Input- agent does not affect the route or process it may be taking later. It is always preferable not to use transitive inte ⁇ retations as this prevents the agents from being self-sufficient.
  • Fig.4 illustrates the logical NOR function using AAOSA.
  • the input agent receives I,I 2 as input, and processes it in the manner described herein. Therefore, in the case of the hyperstructure in Fig. 3c, each agent has its own inte ⁇ retation policy, namely checking its input against the number it represents.
  • a system can be modeled using many different hyperstructures and the choice of the hyperstructure to be used depends on the requirements of the application.
  • Fig. 3d illustrates a different network hyperstructure for implementing the 7-segment display function. This network is modularized based on the optimization of the number of functions, while maintaining a relatively low number of average condition checks. The total number of functions implemented here is 24 (half that of the Fig. 3b and 3c designs).
  • the average condition check if the system is taken as a running on a fully parallel platform, can be calculated as follows.
  • Each possible input between 0 to 9 would occur 1/10 of the time, If input were 1, 2, or 3, we would be checking 1 condition, For inputs 4, 6 and 7, 2 conditions would have been checked, For inputs 0, 3 and 9, the number of conditions checked would be 3, and For input 8, 4 conditions would have to be checked.
  • the average conditions checked would be 2.2.
  • the complexity of the inte ⁇ retation process for each agent usually outweighs the complexity of the processes involved in these two phases.
  • Multi-agent systems having learning capabilities can reduce cost, time, and resources and increase quality in a number of ways:
  • machine learning in a multi-agent setup becomes faster and more robust. Learning can improve performance in AAOSA software by improving speed and accuracy, reducing interactions, providing generalizations, and helping the system to tune in to different user preferences.
  • Learning can be applied to AAOSA in a number of ways depending on the objectives and application of the software. For example, in large and complex software, distributing the learning over a hyperstructure of more simple sub- domains is less complex than centralized learning. Learning can be used to improve the agent's own specialized performance and also to improve its inte ⁇ retation policy to reduce ambiguities. This latter form of learning is driven by the ambiguities themselves.
  • Machine learning algorithms can be used in the learning module of the white box, sometimes in combination. For instance, Reinforcement Learning can be used to fine tune the choice of relevant inte ⁇ retation rules, while rule learning algorithms add or update them. The former is more gradual and statistics-based while the latter changes the agent behavior in quantum leaps and is based on a comparison of the actual inte ⁇ retation with the desired one.
  • Learning can be deployed to automate disambiguation, and/or resolve conflicts between inte ⁇ retation rules in a single agent.
  • the latter case occurs when a single agent has rules that may result in conflicting inte ⁇ retations based on similar decision criteria.
  • weighting the rules based on past experience is a form of learning.
  • the learning algorithm is a very simple rote-learning algorithm that records inte ⁇ retation results for ambiguities explicitly disambiguated for the agent by the user. As we shall see in the next section, this learning algorithm is sufficient in the interactive natural language interface application. In other cases where implicit statistical (history-based) disambiguation is used more often, the learning algorithm can also be more complex. In these cases reinforcement learning methods could be used.
  • AAOSA can be used to parse input given in the form of strings of characters. We will show that the AAOSA parser can parse any context-sensitive grammar and we will discuss the time-complexity of this parser. A parser only inte ⁇ rets input and so an inte ⁇ retation phase similar to that discussed in section 2 is enough. We will also not need any learning therefore a subset of the performatives in the previous section are needed here. The AAOSA parser is of importance to us because it shows the power of the inte ⁇ retation phase of the AAOSA methodology.
  • a claim is a tuple (F, SYMB) where F is the focus and SYMB is a symbol representing the claim.
  • the functions focus(C) is defined to return the focus F of claim C and the function symbol(C) is defined to return the symbol SYMB of claim C.
  • a sequence is a list of claims ⁇ C Intel, ..., C Intel> (m > n) such that:
  • length(I s ) is the length of the input string (i.e., the character count).
  • a language is any set of sentences over an alphabet.
  • a sentence is any string of finite length composed of symbols from the alphabet and the alphabet itself is any finite set of symbols.
  • One way to represent a language is to give an algorithm that determines if a sentence is in a language or not.
  • a more general way is to give a procedure which halts with the answer "yes" for sentences in the language and either does not terminate or else halts with the answer "no" for sentences not in the language.
  • a grammar is a class of generating systems originally formalized by linguists in their study of natural languages.
  • a grammar G by (V N , V ⁇ , P, S).
  • the symbols V N , V ⁇ , P, and S are, respectively, the variables, from which strings of words could be derived, terminals, which play the role of words, productions, which show the relations that exist between various strings of variables and terminals, and the start symbol which is a variable that generates exactly those strings of terminals that are deemed in the language.
  • G the language generated by G with L(G).
  • a string is in L(G) if: • The string consists solely of terminals, and, • The string can be derived from S.
  • a sentential form is a string of symbols from V N ⁇ V ⁇ .
  • a and ⁇ are said to be the left-hand side and the right-hand side of the production rule a ⁇ ⁇ respectively, a consists of a single sentential form, ⁇ may consist of a number of possible sentential forms/?, (usually separated by "
  • V V N u V r ⁇ : The number of elements of V.
  • V * The set of all sentences composed of symbols of V.
  • T V * - ⁇
  • Agent B should be down-chain with respect to agent A, if in the right-hand side of R A , there is a reference to a variable that exists in the left-hand side o R B .
  • agent representing S is the input-agent to this hyperstructure.
  • Input to the system (I s ) is a string of terminals.
  • the input is represented using a set of claims (H 0 ) and the length of the input (length(I s )).
  • the string aabbccdd would be represented as follows:
  • Each agent keeps a list of claims it has made so far. New claims in response to a certain query are sent up-chain when they are made, unless a message is received requesting a stop to the processing of that query (i.e., a message initiated by the input with the performative Forget Problem when parsing has ended). Agents receiving a query respond with the new claims they have made that have not been sent as a response to this query before. Agents complete their response to queries as new claims are made or received. Agents may have to query immediate down-chain agents to complete their claims. Thus, with the hyperstructure being designed according to II, if a claim is made in a down-chain agent that is useful to any other agent X up-chain, X will eventually receive it. An algorithm implementing this process is as follows:
  • agent S The agent representing the start symbol (Agent S or the input agent for the parser) makes any claims it can based on H 0 .
  • Agent S The algorithm for agent S is as follows:
  • Agent S upon receiving responses to its query, will:
  • An input string I s belongs to L(G), where G is the grammar represented by an AAOSA hyperstructure, if the following claim is made: (S, ( ⁇ [0..length(I s ) - l] ⁇ , I s ))
  • An input I s does not belong to L(G), where G is the grammar represented by an AAOSA hyperstructure, if all agents have been visited and no new claims have been made during a cycle in S. For a given agent, a cycle is the time between querying down-chain agents and receiving all responses from them. In the algorithm, when all agents have been visited at least once, we are guaranteed a cycle between each incrementation of the Depth of search. This end condition is correct because only agents make new claims and the claims made are based upon previously made claims. If in one cycle, no new claims were made by all the agents, no new claims would be possible in the succeeding cycles either.
  • Fig. 5 shows the AAOSA hyperstructure for example 1. Note that agents may be down-chain with respect to themselves. There is no need, in this case, for agents to query themselves and they may simply reapply their inte ⁇ retation policies on the claims they have made so far every time they make a new claim. Let us see how this system can parse the input aabbccdd to see if it belongs to the language represented by the grammar in example 1 :
  • Agent S receives input. No new claims apart from the input claims can be made by S at this point, 2) Agent S queries agents A and B (Is-This-Yours?),
  • Agent A makes the following claims and sends them up to agent S:
  • Agent S cannot make any new claims based on Agent A's response, 5) Agent B makes the following claims and sends them up to agent S:
  • Agent S is able to make the following new claim (S, [0..7]) and we conclude that aabbccdd is valid in this language: Note that the order of the sending and receipt of queries and responses does not have any effect on the overall outcome.
  • the grammar in example 1 is that of a context-free grammar.
  • a less restricted form of grammar is the context-sensitive grammar.
  • we use ⁇ x ⁇ to stand the number of symbols in the string x).
  • Example 2 The following grammar is context-sensitive: S ⁇ aSBC I aBC CB ⁇ BC aB ⁇ ab bB ⁇ bb bC ⁇ bc cC ⁇ cc
  • L(G) contains the word a"b"c n for each n ⁇ 1.
  • Fig. 7 illustrates an AAOSA hyperstructure for this grammar. Let us see how this system can parse the input aabbcc to see if it belongs to the language represented by the grammar in example 1 :
  • Agent S queries all at Depth of Search 1
  • Agent "aB” makes claim ( ⁇ [2..2] ⁇ , B) in reply to agent 5's query
  • Agent "bB” makes claim ( ⁇ [3..3] ⁇ , B) in reply to agent _S"s query,
  • Agent "bC” makes claim ( ⁇ [4..4] ⁇ , Q in reply to agent 5"s query, 5) Agent “cC” makes claim ( ⁇ [5..5] ⁇ , C) in reply to agent 5"s query,
  • Agent "CB” receives first responses from down-chains and claims ( ⁇ [3..3] ⁇ , Q and ( ⁇ [4..4] ⁇ , B), 8) S, having received this latest claim from “CB” can claim ( ⁇ [1..3] ⁇ , S) based on ( ⁇ [1..1] ⁇ , a), ( ⁇ [2..2] ⁇ , B), and ( ⁇ [3..3] ⁇ ,
  • the new full sequence also represents an intermediate derivation for the input string.
  • step 2.4 of the above algorithm we are checking to find out if there has been any new claims from propagating queries to a depth more than ( ⁇ +
  • T m T m _ x u ⁇ a I 3 ⁇ e T m _ x A ⁇ - a ⁇ ⁇ a ⁇ ⁇ length(I s ) ⁇ Also:
  • the AAOSA hyperstructure is actually calculating J,, T 2 , T 2 ,...T k where k is the depth of search and the symbol string for each new full sequence consisting of at least one of the new claims made at a depth of search equal to
  • Case 1 Agent B is indirectly down-chain to agent A and agent A can only make new claims once new claims from B have arrived.
  • the time agent A would be waiting for the response from B is at the worst case proportional to the number of agents which in this case is equal to the number of nonterminal symbols m.
  • Case 2 Agent A can make new claims based on the claims it has made. Note that in this case too the Depth so far is incremented (Algorithm line 3.2.2.2). The number of consecutive times A spends in this loop in the worst case is less than length(I s ) or n.
  • n - l processors in each agent, each to be responsible for one of the n - l junctions between input elements (we call these IJ processors). If we use a maximum of (m - 1) processors, each processor representing a junction of two non-terminal symbols in the inte ⁇ retation policy (NJ processor), we will need a maximum of ( ⁇ - m) sets of these processors for every possible combination of the input junctions (NJ sets).
  • a top coordinator processor is also needed for each ⁇ J set.
  • Each D processor stores all claims that are adjacent at the junction it represents.
  • ⁇ J processors in each ⁇ J set are connected to their respective U processors and receive from them all claims with the symbols adjacent at the junction that they represent. The coordinator processors make new claims if all the processors in their respective ⁇ J set return successful claim matches.
  • Adaptability could be about the changing context of interaction or application, but most importantly, the system should be able to adapt to the user's way of expressing her intentions.
  • Two main issues that will have to be taken into account in this regard are generalization and contradiction recovery:
  • a parser after all, tells us if the input string belong to a language or not. Our objective though, is to find the best match for any given input. This means the AAOSA system: • Should be able to accept non-grammatical input (e.g., "Tea for
  • AAOSA should also be able to pinpoint the semantic sub-domains responsible for responding to input. Therefore, we propose a semantic approach to the problem of grammar definition.
  • the designer of a natural language interface application should design a semantic hyperstructure of agents.
  • the input agent at the top would be responsible for receiving input and initiating the query and delegation phase, and the agents representing the functionality of the system would be lowest order nodes of the hyperstructure.
  • the inte ⁇ retation policies should be much fuzzier than that of the parser. For instance, rather than requiring the claims on which a new claim is based to be in sequence (step V in section A), we can require them only to be exclusive.
  • the inte ⁇ retation policies will determine what the best reduction condition is and each agent will compute a confidence factor for its claims based on the extent the reduced claims differ from the desired ones. Using a threshold, claims of higher confidence are used as query responses. For instance, take the grammatical rule A ⁇ BC as an inte ⁇ retation policy.
  • the desired relative position of B and C according to the definition of grammatical production rules, is that B « C. But in our proposed system it would be enough for B and C to be exclusive.
  • a number of heuristics may be used to approximate the extent of difference from the desired status (e.g., differences in order or proximity of the foci). Confidence in the claims themselves will also have to be taken into account when basing a new claim on them.
  • Another main difference between the parser and our proposed natural language system is that the context considered in the reductions of a context- sensitive grammar is limited to the input.
  • the decision to make a claim maybe made based on context information that is not necessarily present in the input.
  • an AAOSA agent may decide to make a claim based on the history of successful claims made, or the status of the semantic domain it is representing, or even based on interactions with the user.
  • inte ⁇ retation is done through a series of claims and delegations carried out by the agents. Agents claim an input string as belonging to them iinternal interpretation), or decide that it belongs to some other agent or agents based on their inte ⁇ retation policies (transitive interpretation). Agents that are not able to find appropriate policies that inte ⁇ ret certain input will consult down-chain agents. In our example the sandwich agent claims input such as "I want a sandwich” because of the presence of "sandwich” (Fig. 10). In this case, the presence of the keyword “Sandwich” is the inte ⁇ retation policy.
  • Transitive inte ⁇ retation would be in the case of the input, "I want to drink”; in which case the processing is delegated to the tea agent by the food agent based on the presence of the keyword “drink” which is a clue as to what kind of food the user is referring to.
  • something unknown to the system has been inputted and should be clarified and possibly learned by the agents. Take for example the input: "I'm thirsty!. Let's say none of the agents claims this input.
  • the input agent can ask the user whether "I'm thirsty! has something to do with telephones or food (i.e., its immediate down-chain agents).
  • the result of this interaction may be learned by the Input agent (e.g., Input agent learns that the input "I'm thirsty! should be delegated to the Food agent).
  • the Food agent in turn not being able to inte ⁇ ret, will ask the user whether "I'm thirsty! has anything to do with tea, biscuits, or sandwiches. Eventually it is up to the Tea agent to learn that "I'm thirsty! belongs to it. To keep the responsibilities from drifting up-chain or down-chain in the hyperstructure of agents, the Tea agent should at this point declare to it's upchain agents (in this case the Food agent) to remove any inte ⁇ retations of "I'm thirsty! that result in the delegation of the input to the tea agent (i.e., uses the Un-learn performative). The Food agent, having received an Un-learn performative and processed it, should in turn propagate it further up-chain.
  • ambiguity is when the natural language input is vague. For example, "I want to eat! would cause the Biscuit agent and the Sandwich agent both to claim it.
  • agents By adding agents to the system, we can extend its capabilities.
  • An example would be adding fax capability to the system in which Fax agent will be added at the same level as the Telephone agent connecting to the same down-chain agents as the telephone agent. Note that by doing so we have also added ambiguity to the system. For instance, "Contact Jila” may result in both the Fax and Telephone agents claiming it.
  • graceful error recovery can be achieved by backtracking to the furthest down-chain point of ambiguity resolved implicitly and interact with the user to resolve it. For instance in the "Again! example if the user really means a re-dial should be attempted, she can express her dissatisfaction by, say, pressing the escape key, and the system will respond with: "Should I re-dial the phone or bring you tea again?
  • AAOSA can be used as a natural language interface to electronic messenger systems, home theater systems, and for other applications as well.
  • Table 4 sets forth certain notable features in the home theater system embodiment.
  • Embodiments of AAOSA can been implemented in Java because of its unique portability and multi-platform execution capabilities and multithreading features. They can use simple rote learning as the learning module in the white-box, or other, more robust machine learning methods may be used.
  • the AAOSA software architecture can be used to effectively implementation a natural language interactive interface.
  • the architecture is flexible, primarily because there is no rigid predetermination of valid input. It is modular providing for easier revision, extension and development.
  • AAOSA agents can be re-used inside an application or in other software.
  • the independent nature of AAOSA agents provides for an inherently parallel architecture. Agents can run and communicate over a network of heterogeneous hosts. Run-time addition of new AAOSA agents is possible and therefore incremental development and evaluation is possible. Following guidelines set by the original designer; other designers can also contribute to a system making it commercially attractive.
  • the built-in learning and ambiguity resolution features make AAOSA a more intelligent software architecture.
  • a message includes, among other things, queries, commands, and responses to queries.
  • a message is considered herein to be within the domain of responsibility of a given agent if: (a) the message, or part of it, is within the given agent's local domain of responsibility (i.e., the special processing unit of the agent has itself been assigned the responsibility to take some action in response to the message, or in response to part of the message), and/or (b) the message, or part of it, is within the given agent's downchain domain or responsibility (i.e., the agent knows of one or more further agents to whom the message should be routed).
  • the arrangement of agents might, for example, satisfy the definition of a hyperstructure.
  • the arrangement of agents can be described as a network.
  • hyperstructures and hierarchies are special cases of a network.
  • a simple chain of agents is a special case of a hierarchy and a single agent is a special case of a chain of agents. All these forms and others are considered herein to be kinds of networks.
  • an agent which is part of a community of agents all having the same domain of responsibility can be queried, in an appropriate embodiment, by querying the community of which it is part. That is, the querying of a group of agents is considered herein to include the querying of one or more agents within the group.
  • a given message, signal or event is "responsive" to a predecessor message, signal or event if the predecessor signal or event influenced the given signal or event. If there is an intervening processing element or time period, the given message, event or signal can still be “responsive” to the predecessor signal or event. If the intervening processing element combines more than one message, signal or event, the output of the processing element is considered “responsive" to each of the message, signal or event inputs. If the given message, signal or event is the same as the predecessor message, signal or event, this is merely a degenerate case in which the given message, signal or event is still considered to be "responsive" to the predecessor message, signal or event.

Abstract

D'une manière globale, la phase d'interprétation d'un système faisant appel à une architecture logicielle orientée agent adaptatif permet aux agents interrogés de répondre à des interrogations avant d'avoir obtenu la totalité de leur propres réponses de la part de leurs propres agents situés en aval dans la chaîne. Dans une première réalisation, les agents interrogés répondent après une délai précis suivant la réception d'une demande, qu'ils aient ou non reçu toutes les réponses en provenance de leurs agents situés en aval dans la chaîne. Dans une deuxième réalisation, l'agent interrogé présente des demandes à l'agent amont qui a émis l'interrogation, en réponse à chaque demande que l'agent interrogé reçoit de la part de ses propres agents aval. Dans une troisième réalisation, l'agent interrogé peut recevoir une interrogation particulière plus d'une fois, et en réponse à chacune de ces interrogations, l'agent répond par les demandes dont il dispose à ce moment. Pour limiter la durée de temps pendant laquelle les interrogations sont actives dans le réseau, et donc l'intervalle de temps pendant lequel de nouvelles demandes peuvent encore être lancées, l'agent à l'origine de l'interrogation peut envoyer un message « oublier problème » ou « donner suite » dans le réseau après une période de temps donnée. Dans une réalisation différente ou complémentaire, l'agent à l'origine de l'interrogation peut ajouter une indication de « portée de recherche » à chaque interrogation, de manière à empêcher l'interrogation de se propager au-delà d'un nombre indiqué d'agents. Dans cette dernière réalisation, l'agent à l'origine de l'interrogation peut ensuite soumettre la même interrogation aux mêmes agents situés en aval, mais avec une indication de portée de recherche accrue si par exemple l'agent à l'origine de l'interrogation n'est pas encore satisfait avec les demandes reçues en réponse à la première interrogation.
PCT/US2000/041910 1999-11-05 2000-11-06 Phase d'interpretation pour architecture logicielle orientee agent adaptatif WO2001037064A2 (fr)

Priority Applications (1)

Application Number Priority Date Filing Date Title
AU27510/01A AU2751001A (en) 1999-11-05 2000-11-06 Interpretation phase for adaptive agent oriented software architecture

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US16385999P 1999-11-05 1999-11-05
US60/163,859 1999-11-05

Publications (2)

Publication Number Publication Date
WO2001037064A2 true WO2001037064A2 (fr) 2001-05-25
WO2001037064A3 WO2001037064A3 (fr) 2002-02-21

Family

ID=22591890

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US2000/041910 WO2001037064A2 (fr) 1999-11-05 2000-11-06 Phase d'interpretation pour architecture logicielle orientee agent adaptatif

Country Status (2)

Country Link
AU (1) AU2751001A (fr)
WO (1) WO2001037064A2 (fr)

Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5638494A (en) * 1994-03-15 1997-06-10 Mitel Corporation Adaptive communication system
US5826020A (en) * 1994-09-30 1998-10-20 Hewlett-Packard Co. Workflow real time intervention
US5890146A (en) * 1996-05-02 1999-03-30 U.S. Philips Corporation Adaptive process modelling and control

Patent Citations (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5638494A (en) * 1994-03-15 1997-06-10 Mitel Corporation Adaptive communication system
US5826020A (en) * 1994-09-30 1998-10-20 Hewlett-Packard Co. Workflow real time intervention
US5890146A (en) * 1996-05-02 1999-03-30 U.S. Philips Corporation Adaptive process modelling and control

Also Published As

Publication number Publication date
WO2001037064A3 (fr) 2002-02-21
AU2751001A (en) 2001-05-30

Similar Documents

Publication Publication Date Title
Ranganathan et al. An infrastructure for context-awareness based on first order logic
Moldt et al. Multi-agent-systems based on coloured Petri nets
DeLoach Engineering organization-based multiagent systems
Whigham Search bias, language bias, and genetic programming
US6990670B1 (en) Interpretation phase for adaptive agent oriented software architecture
Clave et al. Towards Maude 2.0
Lin et al. A schema-based approach to specifying conversation policies
Hurkens et al. The logic of recursive equations
US20080021751A1 (en) Method and system for transforming orders for executing them in standard workflow engines
WO2001037064A2 (fr) Phase d'interpretation pour architecture logicielle orientee agent adaptatif
Hodjat et al. Applying the adaptive agent oriented software architecture to the parsing of context sensitive grammars
Hodjat et al. Introducing the adaptive agent oriented software architecture and its application in natural language user interfaces
Bleyer Multi-agent systems for information retrieval on the world wide web
Box In the Adaptive Agent Oriented Software Architecture (AAOSA) paradigm we encourage the exploitation of this feature as much as possible so that the designer of an AAOSA based system is faced with as simple a task as possible.
Hodjat et al. An adaptive agent oriented software architecture
Leni-nlng In the Adaptive Agent Oriented Software Architecture (AAOSA) paradigm we encourage the exploitation of this feature as much as possible so that the designer of an AAOSA based system is faced with as simple a task as possible. AAOSA is a software methodology that proposes the break-up of complex software into a community of simpler, independent, collaborating, adaptive, message-driven com
Lam et al. Distributed defeasible speculative reasoning in ambient environment
Lee et al. Toward intention aware semantic web service systems
Neovius et al. A formal model of context-awareness and context-dependency
Poggi HOMAGE: a heterogeneous object-based environment to develop multi-agent systems
Neruda Ontology Description of Jade Computational Agents in OWL-DL
Vanthienen et al. Mapping Decision Tables to Expert System Shells: An Implementation in AionDS
Fred et al. Syntax-Directed Translation Schemes for Multi-Agent Systems Conversation Modelling
Hammer et al. Deliberative Agents in Dynamic Environments, Using Jason and NARS
Sabas et al. Applying a New Multidimentional Framework to the Evaluation of Multiagent System Methodologies

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A2

Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY BZ CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG UZ VN YU ZA ZW

AL Designated countries for regional patents

Kind code of ref document: A2

Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG

121 Ep: the epo has been informed by wipo that ep was designated in this application
DFPE Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101)
AK Designated states

Kind code of ref document: A3

Designated state(s): AE AG AL AM AT AU AZ BA BB BG BR BY BZ CA CH CN CR CU CZ DE DK DM DZ EE ES FI GB GD GE GH GM HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MA MD MG MK MN MW MX MZ NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT TZ UA UG UZ VN YU ZA ZW

AL Designated countries for regional patents

Kind code of ref document: A3

Designated state(s): GH GM KE LS MW MZ SD SL SZ TZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE TR BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG

REG Reference to national code

Ref country code: DE

Ref legal event code: 8642

122 Ep: pct application non-entry in european phase