Agent Architectures & Languages. Heikki Helin

Transcription

1 Agent Architectures & Languages Heikki Helin

2 Agent Architectures

3 Introduction Different architectures Deliberative approach Reactive approach Hybrid approach

4 Agent Architectures Definition Maes: An architecture proposes a particular methodology for building an autonomous agent. It specifies how the overall problem can be decomposed into subproblems, i.e. how the construction of the agent can be decomposed into the construction of a set of component modules and how these modules should be made to interact. The total set of modules and their interactions has to provide an answer to the question of how the sensor data and the current internal state of the agent determine the actions (effector outputs) and future internal state of the agent. An architecture encompasses techniques and algorithms that support this methodology.

5 Generic Model Agent sensor input Action output Environment

6 Deliberative Agent Introduction Explicit symbolic model of the world in which decisions are made via logical reasoning, based on pattern matching and symbolic manipulation Sense-plan-act problem-solving paradigm of classical AI planning systems Examples of deliberative architectures BDI GRATE*, HOMER Shoham: Agent-Oriented Programming

7 Deliberative Agent basic architecture Agent E ff ff S en sensor input s o rs World Model Planner Plan executor e ct ct o rs Action output o rs

8 Deliberative Agent disadvantages Performance problems transduction problem time consuming to translate all of the needed information into the symbolic representation, especially if the environment is changing rapidly. representation problem how the world-model is represented in symbolically and how to get agents to reason with the information in time for the results to be useful. Late results may be useless Does not scale to real-world scenarios

9 Reactive Agent Introduction Reactive agents have at most a very simple internal representation of the world, but provide tight coupling of perception and action Behaviour-based paradigm Intelligence is a product of interaction between an agent and its environment Do we really need abstract reasoning?

10 Reactive agent basic architecture Agent Stimulus-response behaviours S en State 1 Action 1 E ff ff sensor input s o rs State 2. Action 2. e ct ct o rs Action output State n Action n

11 Reactive Agent Each behaviour continually maps perceptual input to action output Reactive behaviour: Example: action: S -> A where S denotes the states of the environment, and A the primitive actions the agent is capable of perform. action(s) = Heater off, if temperature OK Heater on, otherwise

12 Reactive Agent Problems a great deal of local information needed learning? Typically handcrafted Development takes a lot of time Impossible to build large systems? Can be used only for its original purpose Examples Brooks: subsumption architecture

13 Hybrid Agent Introduction Combination of deliberative and reactive behaviour An agent consists of several subsystems Subsystems that develop plans and make decisions using symbolic reasoning (deliberative component) Reactive subsystems that are able to react quickly to events without complex reasoning (reactive component) Layered architectures

14 Hybrid agent basic architecture Agent Deliberative component sensor input S en en World Model observations Planner modifications Plan executor E ff ff Action output s Reactive component e ct ct o rs rs o rs rs State 1 Action 1 State 2. State n Action 2 Action n.

15 Hybrid agent layering techniques Action output Layer n Layer n Layer n-1 Layer n-1. Sensor input. Action output Layer 2 Layer 2 Layer 1 Layer 1 Sensor input Action output

16 Hybrid Agent example - InteRRaP Cooperation layer Social knowledge Plan layer Planning knowledge Behaviour layer World model World interface Perceptual input action output

17 Hybrid agent examples Examples: InterRaP Touring Machines Procedural Reasoning System (PRS) 3T...

18 Agent Languages

19 Agent Oriented Programming Agent Oriented Programming (Shoham) first attempt towards agent-oriented programming April programming language Agent programming language Agent communication language

20 Agent Oriented Programming introduction AOP = agents are viewed as computational entities possessing formal versions of mental state, and in particular formal versions of beliefs, capabilities, commitments, and possibly a few other mentalistic-sounding qualities

21 Agent Oriented Programming agent0 Agent is an entity consisting: beliefs B t aφ a = agent, t = time, φ = sentence commitments CMT t a,bφ commitment rules to add new commitments capabilities what agent can do

22 Agent Oriented Programming Example of commitment rule (COMMIT ( ( agent, REQUEST, DO(time, action) ), ;;; msg condition (B, [now, Friend agent] AND CAN(self, action) AND NOT [time, CMT(self, anyaction)] ), ;;; mental condition self, DO (time, action))

23 Agent Oriented Programming Initialize mental state and capabilities define rules for making new commitments Control Data flow Incoming messages clock Update mental state Mental state and capability Execute commitments for current time Outgoing messages

24 April Agent Process Interaction Language Introduction Features Basic functionality functions, procedures, messages, Communication Example: Contract Net protocol

25 April introduction Language for implementing globally distributed symbolic applications Application areas: DAI, MAS, First version developed on Esprit contract in multi-agent systems Imagine ( ) Now being jointly developed and extended by Imperial College (London) and Fujitsu Labs in California

26 April features Publically named processes and the Internet globally unique identities (handles) Process oriented language Running April program consist of a number of loosely connected processes which interact via message passing only Pattern based language Heterogeneous environment Macro language APRIL++ (brings in oo features) API interface to C and Java External components looks like April processes

27 April hello world program{ main(){ "Hello world\n" >> stdout } } execute main; Send message to process stdout

28 April Program structure program { N 1 =def 1 ; N 2 =def 2 ; N k =def k ; } execute N; Each N i =def i is name of a function or procedure N is a procedure that will be executed when program is loaded

29 April Function Definitions f={ ptn1 => exp1 ptn2 => exp2 ptnk => expk }; Each ptn must be a pattern for the same type of argument

30 April Function Definitions - Example greater_of={ (n,n) => n (n,m)::n>m => n (n,m) => m }; P::T is a test pattern

31 April receive statement receive{ ptn1 ->> stmt1 ptn2 ->> stmt2 ptnk ->> stmtk }; Each ptn can be for a different message type (or timeout)

32 April guarded commands Each process has exactly one incoming message queue Guarded command message_pattern :: test -> action Each message in the queue is tested against the message pattern if message matches the message pattern and test is true, the message is removed from the queue and the action is executed

33 April simple server greater_of_server = { () -> { repeat ( greater_of_is, X, Y):: ->> ( result_is, greater_of(x,y)) >> replyto M ->> ( unregognized, M) >> replyto until quit::sender==creator() } };

34 April generic server Server ([any]{}?t) { repeat { [do, any?arg] -> { T(arg); done >> replyto } } until quit };

35 April sending messages Msg >> To Msg is any expression To is a handle The message Msg is sent to the To process hello >> replyto hello >> handle(tgt="",name="bib",home=host(),locs=[host ()])

36 April sending messages (cont.) >> normal send operator ( msg, X) ->> ( reply, Y) >> replyto >>> message forwarding operator >>* multicast send

37 April sending messages (cont.) interface = { () -> { H1 = spawn first_server(); H2 = spawn second_server(); while true do ( forward_to, first_server, M) ->> M >>> H1 ( forward_to, second_server, M) ->> M >>> H2 quit ->> { quit >>* [H1,H2]; break} }};

38 April inter-process communication P 2) send handle H 3) ( greater_of_is, ) Client 1) H=spawn greater_of_server() 4) ( result_is, ) H

39 1) award 4) request DF April Example - contract net Agent 5) reply 2) breakup 6) spawn find_contractor(agents, ) subtasker 3) subtasks 9) ( selected, ) find_ contractor 7) task_msg 8) bid_msg agent 8) bid_msg agent 7) task_msg 7) task_msg agent

40 April Example - contract net Task announcement message message type (task_announcement) ContractId (Symbol) EligibilitySpec (String) Must have... TaskDescription (String) What should be done BidSpec (String) What should the bid contain ExpiryTime (Number) One hour, one minute,...

41 April Example - contract net task_msg::=(symbol?id, string?elig_spec, string?descr, string?bid_spec, number?expiry); task( ID3105, Must have, Calculate, Specify, now()+120)

42 April Example - contract net find_contractor = { (Agents, task_msg?t, good_enough, best_reply) -> { T >>* Agents; Replies := []; repeat { bid_msg?p::sender in Agents ->> if good_enough(p) then { ( selected, P) >> creator(); abort()} else Replies := [(sender, P),..Replies] } until alarm T.expiry; ( selected, best_reply(replies)) >> creator(); }

43 April more information F.G.McCabe and K.L.Clark. April - Agent PRocess Interaction Language. In N. Jennings and M. Wooldridge (eds.) Intelligent Agents: Theories, Architectures, and Languages,(LNAI volume 890), pages Springer-Verlag, < Keith Clark, Nikolaus Skarmeas, and Frank McCabe. Agents as Clonable Objects With Knowledge Base State. In Victor Lesser, editor, Proceedings of the First International Conference on Multi-Agent Systems.1995 < K.L.Clark and F.G.McCabe. Programming in April. Draft of the first five chapters available at < Source code & Manual

44 Other Tools & Languages Java based tools JESS (Java Expert System Shell) Java implementation of CLIPS JAM (Java Agent Model) BDI FIPA platforms Jade (TILAB), FIPA-OS (Emorphia) Both available as open source AAP (April Agent Platform) Many more