Action-Based Imperative Programming with YAGI

786 views

Published on

Alexander Ferrein, Gerald Steinbauer, Stavros Vassos, In Proceedings of the 8th International Workshop on Cognitive Robotics (CogRob-2012) of the 26th AAAI Conference (AAAI-2012) Conference, Toronto ON, Canada, 2012.

http://stavros.lostre.org/2012/07/28/yagi-cogrob-2102/

Many tasks for autonomous agents or robots are best de- scribed by a specification of the environment and a specification of the available actions the agent or robot can perform. Combining such a specification with the possibility to imperatively program a robot or agent is what we call the action-based imperative programming. One of the most successful such approaches is Golog. In this paper, we draft a proposal for a new robot programming language YAGI, which is based on the action-based imperative programming paradigm. Our goal is to design a small, portable stand-alone YAGI interpreter. We combine the benefits of a principled domain specification with a clean, small and simple programming language, which does not exploit any side-effects from the implementation language. We discuss general requirements of action-based programming languages and outline YAGI, our action-based language approach which particularly aims at embeddability.

Published in: Education, Technology
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
786
On SlideShare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
6
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Action-Based Imperative Programming with YAGI

  1. 1. ACTION-BASED IMPERATIVEPROGRAMMING WITH YAGIAlexander Ferrein, Gerald Steinbauer, Stavros Vassos
  2. 2. Yet Another Golog Interpreter2  Golog [Levesque; Reiter; Lesperance; Lin; Scherl, „97]  Agent programming language
  3. 3. Yet Another Golog Interpreter3  Golog [Levesque; Reiter; Lesperance; Lin; Scherl, „97]  Agent programming language  Can be used to specify the high-level behavior of robots, software bots, and systems using conditionals, loops, and more sophisticated features  Instead of operations on variables, it is based on actions that affect changing properties of the application domain Domain description High-level Program
  4. 4. Yet Another Golog Interpreter4  YAGI: aiming toward a (more) practical Golog implementation  Adopt a familiar syntax from popular software developing languages (C++, Java, Python, …)  Identify a minimal subset of the full Golog functionality that can be used by non-experts  Allow to be easily embedded to larger software projects and frameworks
  5. 5. The “smart elevator” example5  Simple running example to illustrate some of the basic functionality of Golog and YAGI  Think of an elevator for a busy office center as an agent that follows a given high-level plan  Whenever there are pending floor requests pick one and serve the corresponding floor
  6. 6. Agent programming with Golog6  Logical domain description  High-level program Domain description High-level Program
  7. 7. Agent programming with Golog7  Logical domain description  High-level program  Specifies the behavior of the agent as a sketch of a plan using programming constructs Domain description High-level Program Pick a floor with the button pressed and serve
  8. 8. Agent programming with Golog8  Logical domain description  Fluents: the changing properties of the domain  Actions: specify how the fluents change  High-level program  Specifies the behavior of the agent as a sketch of a plan using programming constructs Domain description High-level Program Fluents: CurrentFloor, On Pick a floor with the button Actions: Up, Down, TurnOff pressed and serve
  9. 9. Agent programming with Golog9  Situation calculus  FOL language specifically designed for reasoning about action and change  Fluents: Similar to database relations but also conditioned on a situation argument: F(x,y,S0)  S0 is the initial situation  do(Α,S0) is the resulting situation after action A has been performed in S0  Situations are used to refer to future states of the world F(x,y, do(A,S0))
  10. 10. Agent programming with Golog10  Logical domain description  Fluent CurrentFloor(x,s): elevator is located at floor x  CurrentFloor(4,S0)  Fluent On(x,s): button pressed at floor x  On(3,S0), On(5,S0) Domain description Fluents: CurrentFloor, On Actions: Up, Down, TurnOff
  11. 11. Agent programming with Golog11  Logical domain description  Action Up(x)/Down(x): move up/downwards to floor x  CurrentFloor(x,do(a,s))  a=Up(x)  a=Down(x)  CurrentFloor(x,s)  y a=Up(y)  y a=Down(y)  Poss(Up(x),s)  x ( CurrentFloor(y,s)  y<x ) Domain description Fluents: CurrentFloor, On Actions: Up, Down, TurnOff
  12. 12. Agent programming with Golog12  High-level program  Specifies the behavior of the agent as a sketch of a plan using programming constructs  π x. ( (Up(x) | Down(x)); TurnOff(x); open(); close() ) High-level Program Pick a floor with the button pressed and serve
  13. 13. Agent programming with Golog13  High-level program  Specifies the behavior of the agent as a sketch of a plan using programming constructs  π x. ( (Up(x) | Down(x)); TurnOff(x); open(); close() ) High-level Program  ServeAFloor() Pick a floor with the button pressed and serve
  14. 14. Agent programming with Golog14  High-level program  Off-line vs On-line execution  π x. ( (Up(x) | Down(x)); TurnOff(x); open(); close() ) Domain description High-level Program Fluents: CurrentFloor, On Pick a floor with the button Actions: Up, Down, TurnOff pressed and serve
  15. 15. Agent programming with Golog15  Golog programming constructs
  16. 16. Agent programming with Golog16  Logical domain description  Precise logical formulation based on situation calculus  High-level program  Precise logical formulation based on Golog  Typically implemented on top of some Prolog interpreter Domain description High-level Program Fluents: CurrentFloor, On Pick a floor with the button Actions: Up, Down, TurnOff pressed and serve
  17. 17. Agent programming with Golog17  Programming requires understanding the semantics  CurrentFloor(x,do(a,s))  a=Up(x)  a=Down(x)  CurrentFloor(x,s)  y a=Up(y)  y a=Down(y)  Poss(Up(x),s)  x ( CurrentFloor(y,s)  y<x ) π x. ( (Up(x) | Down(x)); TurnOff(x); open(); close() )  Features of Prolog are implicitly used in the domain specification and the high-level program
  18. 18. Agent programming with Golog18  Programming requires understanding the semantics  CurrentFloor(x,do(a,s))  a=Up(x)  a=Down(x)  CurrentFloor(x,s)  y a=Up(y)  y a=Down(y)  Poss(Up(x),s)  x ( CurrentFloor(y,s)  y<x ) π x. ( (Up(x) | Down(x)); TurnOff(x); open(); close() )  Features of Prolog are implicitly used in the domain specification and the high-level program  Confusing in practice for non-expert users
  19. 19. Yet Another Golog Interpreter19  Aiming toward a (more) practical Golog implementation  Firstiteration (this paper): YAGI language specification as a stand-alone interpreted programming language with familiar syntax
  20. 20. Yet Another Golog Interpreter20  YAGI language  Make fluents look like variables of popular programming languages  Make actions look like functions of popular programming languages  Unify the domain description and high-level program using this metaphor
  21. 21. Yet Another Golog Interpreter21  Make fluents look like variables of popular programming languages  CurrentFloor(2,S0)  YAGI>> fluent CurrentFloor; YAGI>> On = {2};  Dictionary/Associative array/Map  Associatesto a flat list of values  Multi-dimensional key (here On is 0-dimensional)
  22. 22. Yet Another Golog Interpreter22  Make fluents look like variables of popular programming languages  On(3,S0), On(5,S0)  YAGI>> fluent On; YAGI>> On = {1,3}  x ( On(x,S0)  (x=1  x=3) )  Note that we (currently) aim for complete knowledge
  23. 23. Yet Another Golog Interpreter23  Make fluents look like variables of popular programming languages  Set-theoretic operations on the list of values  YAGI>> On += 5 YAGI>> On {1,3,5} YAGI>> On -= 1 {3,5} YAGI>> 3 in On True
  24. 24. Yet Another Golog Interpreter24  Make actions look like functions of popular programming languages  Action Up(x)  YAGI>> action Up($n) ... end action  Specify local variables using a $ prefix  Specify preconditions and effects as YAGI statements between fluents
  25. 25. Yet Another Golog Interpreter25  Make actions look like functions of popular programming languages  Action Up(x)  YAGI>> action Up($n) precondition: ... effect: currentFloor = {$n} end action
  26. 26. Yet Another Golog Interpreter26  Make actions look like functions of popular programming languages  Action Up(x)  YAGI>> action Up($n) precondition: ... effect: for $i in On do currentFloor += $i end for end action
  27. 27. Yet Another Golog Interpreter27  Use the same syntax/metaphor to specify the high-level program  YAGI>> proc serveAFloor() pick $n from On such choose up($n) or down($n) end choose turnOff($n); open(); close(); end pick end proc
  28. 28. Yet Another Golog Interpreter28  High-level program calls: Each YAGI call is searched offline and then executed online  YAGI>> On {3,5} YAGI>> serveAFloor() YAGI>> On {5} YAGI>> serveAFloor() YAGI>> On {}
  29. 29. Yet Another Golog Interpreter29  High-level program calls: Each YAGI call is searched offline and then executed online  YAGI>> On {3,5} YAGI>> serveAFloor(); serveAFloor() YAGI>> On {}
  30. 30. Yet Another Golog Interpreter30  Interoperability using string signals  (Inspired from web services, aiming for XML-like or JSON-like interoperability)  YAGI>> action Up($n) precondition: ... effect: ... signal: "Move up to floor " + $n end action
  31. 31. Yet Another Golog Interpreter31  High-level program calls: Each YAGI call is searched offline and then executed online  YAGI>> serveAFloor() “Move up to floor 5” “Turn-off button at floor 5” “Open elevator door” “Close elevator door” YAGI>> serveAFloor() “Move up to floor 3” “Turn-off button at floor 3” “Open elevator door” “Close elevator door”
  32. 32. Yet Another Golog Interpreter32  High-level program calls: Each YAGI call is searched offline and then executed online  YAGI>> serveAFloor(); serveAFloor() “Move up to floor 5” “Turn-off button at floor 5” “Open elevator door” “Close elevator door” “Move up to floor 3” “Turn-off button at floor 3” “Open elevator door” “Close elevator door”
  33. 33. Situation calculus semantics33  YAGI operates as a persistent object that  Holdsa situation calculus basic action theory  Responds to a YAGI call by  finding an appropriate sequence of actions to perform following Golog semantics  updating the theory by progressing the initial knowledge based executing each action one by one  producing signals along the way  Responds to a YAGI declaration by updating directly the specification of the theory
  34. 34. Situation calculus semantics34  Differences with the family of Golog languages  Complete knowledge  No while loops in the language (only for loops)  Addition and equality support with Presburger arithmetic  Progression is built-in the semantics
  35. 35. Current and future work35  Aiming toward a (more) practical Golog implementation  Firstiteration (this paper): YAGI language specification as a stand-alone interpreted programming language with familiar syntax  YAGI BNF spefication in the paper  Parser available online: http://code.google.com/p/yagi/  Second iteration (current and future work): YAGI prototype interpreter  C++, Java, Lua  On top of existing Prolog implementation
  36. 36. Conclusions36  YAGI: First formal specification of Golog as a non logic-based programming language  A roadmap for some essential requirements  Non-functional requirements  Q1: Familiarity  Q2: Embeddedness  Q3: Interoperability  Q4: Transparency  Functional requirements  F1-F12: Action-based, imperative, goal-oriented, arithmetic, queries, null values, probabilistic values, sensing, …
  37. 37. ACTION-BASED IMPERATIVEPROGRAMMING WITH YAGIAlexander Ferrein, Gerald Steinbauer, Stavros Vassos

×