Transcript JRobin - LES PUC-Rio

Model-Driven Engineering
of Intelligent Agents
Jacques Robin
Ontologies
Reasoning
Components
Agents
Simulations
Outline





Model-driven engineering
Model-driven software components
Model-driven components for intelligent agents
The ORCAS project: automated reasoning components
The IATE project: agent environment product line
Model-Driven Engineering
Abstraction
Scale
Current Standard Practice:
Object-Oriented Development
UML + NL
Requirements
UML
Model
Source
Code
Virtual
Machine
Code
Binary
Code
Executability
Scale
Model-Driven Engineering
Abstraction
Scale
Today’s MDD:
Extreme Modeling
UML/OCL
Requirements
UML/OCL
Specification
PIM
UML/OCL
Realization
PIM
Profiled
UML/OCL
Realization
PSM
Source
Code
Virtual
Machine
Code
Binary
Code
Executability
Scale
Model-Driven Engineering
Abstraction
Scale
Model
Refinement
Patterns
UML/OCL
Requirements
Model
Translation
Patterns
UML/OCL
Specification
PIM
UML/OCL
Realization
PIM
Tomorrow’s MDD:
UML Programming
Profiled
UML/OCL
Realization
PSM
Source
Code
Virtual
Machine
Code
Binary
Code
Executability
Scale
Model-Driven Software Components:
the KobrA method
 Comprehensive, prescriptive methodology
 Coherently integrates most software reuse concepts
+ Aspect-Oriented Development
+ Built-in Component Contract
Test Generator
Model-Driven Software Components:
the KobrA method
 Full Life-Cycle
Components
 Intra and interdiagram consistency
and completeness
rules
 Recursive
decomposition of
components in subcomponents
 Realization models
fully refined, code
generation through
pure translation
Component-Based
Multi-Agent Simulation Engineering
Inference
Engine
Component
Knowledge
Base
Generator
Domain
Knowledge
Base
Environment
Simulator
Component
IATE
Simulation
Independent
Domain
Model
Environment
Characteristics’
Model
Perceptions, Actions
Perceptions, Actions
Agent N Component
Agent 1 Component
Domain
Knowledge
Base
Inference Engine Component
Domain
Independent
Knowledge
Base
Inference
Engine
Component
Inference
Engine
Component
Inference Engine
Component
Domain
Independent
Knowledge
Base
ORCAS
Domain
Knowledge
Base
ORCAS motivation: why automated
reasoning still so rarely used today?
 Too costly to develop AR services from scratch for specific
applications:
AR services are large, conceptually very complex software
They require hard to find software engineers with strong AI background
 Too costly to integrate available AR software in larger systems:
Rarely based on mainstream IT standards (e.g., exotic Prolog extensions)
Rarely comes with adequate middleware, (e.g., only API to C)
Single software rarely provides all AR services required by application
 Too costly to customize or extend available AR software for
specific applications:
Never comes with models or test suite (at best with source code)
Often comes without reasoning explanation GUI
Never integrated with standard CASE tool or IDE
ORCAS: long-term goal
and methodology
Automated Reasoning:
• Adaptive Constraint Handling Rules
Challenging
Testbed
• Transaction Frame Logic
Software Engineering:
• Model-Driven Development
• Component-Based Development
• Aspect-Oriented Development
Usability
Extensibility
• Built-in Contract Testing
KobrA Method:
• Customized for Automated Reasoning
• Upgraded to Latest OMG Standards
Reusable Reasoning Components:
• w/ Full Artifact Suite: UML Requirement, Analysis and Design Models, AspectJ Code, Test Suite
• For Deduction, Abduction, Induction, Belief Revision, Constraint Solving, Optimization
• In Logical, Probabilistic, Decision-Theoretic Settings
• w/ Object-Oriented, First-Order Rewrite Rules Automatically Generated from UML models
ORCAS: 4-layer
model-driven development
Knowledge
Level
KobrA
UML/OCL/QVT
Model
UML/OCL/QVT
to CHORD
Compiler
Formalization
Level
Implementation
Level
CHORD
Base
AspectJ/Java
or Aspect#/C#
Source Code
CHORD to
AspectJ/Java
or Aspect#/C#
Compiler
Deployment
Level
.Jar or DLL
Component
AspectJ Weaver
& Java Compiler
or Aspect# Weaver
& C# Compiler
Applies to both:
 Domain-dependent application knowledge base development
 Domain-independent inference engine development
CHORD: Motivation
 ORCAS’s middle-tier knowledge representation formalism:
 Object-Oriented Rule-Based Constraint Programming
 Why constraint programming?
 Showed to subsume most other reasoning tasks:
 Deduction, Abduction [Abdennadher & Schutz], Belief Revision [Wolf],
and Optimization [Dechter]
 In Logical [Abdennadher & Schutz], Probabilistic [Angelopoulos]
and Decision-Theoretic [Dechter] settings
 Why rule-based?
 Rules easier to specify and revise than algorithms for non-programmers domain
experts
 Declarative semantics in formal logic allows model checking
 Declarativeness allows fast prototyping (i.e., agile development)
 Why object-oriented?
 Easier compilation from object-oriented UML/OCL upper-tier
 Easier compilation to object-oriented Java, C# or C++ lower-tier
 Reuse through inheritance
Integrating two versatile formal
knowledge representation languages
CHORD = CHRD Rules + Frame Logic Objects
CHRD
Constraint Handling Rules w/ Disjunction
Subsumes:
•
•
•
•
•
•
•
Prolog, Deductive DB
Production Systems
Term Rewriting Systems
Concurrent Constraint Logic Programs
Truth-Maintenance Systems
Abductive Logic Programs
(Semantic Web) Description Logics
Transaction Frame Logic
Subsumes:
•
•
•
•
•
•
•
•
Prolog, Deductive DB
Tabled Logic Programs
High-Order Logic Programs
Object-Oriented Logic Programs
Transactional, Relational DB
Object-Oriented, Object-Relational DB
Semi-Structured XML DB
Semantic Web RDF DB
Available Implementations: Prolog, Java
Available Implementations:
Logic-Based Formal Semantics
• Prolog, Java, C++
Logic-Based Formal Semantics
CHRD in a nutshell
 Knowledge representation language for theorem proving integrating
term rewriting, forward chaining and backtracking
 Based on subset of first-order predicate logic
 Distinguishes between two classes of predicate symbols:
 Locally defined predicates (in subject CHR component)
 Externally defined predicates (in server CHR components)
 Extends CHR that was created for declarative programming of
constraint solvers
 CHRD program: logical conjunction of rewrite rules (clauses)
 Two types of rules:
 Constraint simplification rules (logical equivalences, rewrite rules)
 Constraint propagation rules (logical implications, production rules)
CHRD: simplification rules
 head  guard | body
 l10(…,U,…)  …  ln0 (…,V,…)  e1(…,W,…)  em(…,X,…) |
(p11(…,Yi,…)  …  p1p(…, Yj,…))  …  (pk1(…,Yk,…)  …  pkq(…,Yl,…))
 Example:
 min(X,Y,Z)  int(Z)  int(Y)  int(Y)  X  Y | Z = X.
 Logical declarative semantics:
 …,U,…,V,…,W,…X,… (e1(…,W,…)  em(…,X,…)) 
(l10(…,U, …)  …  ln0 (…,V, …)
 ( …,Yi,…,Yj,… p11(…,Yi,…)  …  p1p(…, Yj,…))
 …
 …,Yk,… Yj,… pk1(…,Yk,…)  …  pkq(…,Yl,…))))
 Operational semantics:
 If external solver component query returns true on guard
then substitute constraints matching head in local constraint store
with constraints in rule body modulo variable substitution
 Otherwise try other rules
CHRD: propagation rules
 head  guard | body
 l10(…,U,…)  …  ln0 (…,V,…)  e1(…,W,…)  em(…,X,…) |
(p11(…,Yi,…)  …  p1p(…, Yj,…))  …  (pk1(…,Yk,…)  …  pkq(…,Yl,…))
 Example:
 min(X,Y,Z)  int(Z)  int(Y)  int(Y) | Z  X  Z  X.
 Logical declarative semantics:
 …,U,…,V,…,W,…X,… (e1(…,W,…)  em(…,X,…)) 
(l10(…,U, …)  …  ln0 (…,V, …)
 ( …,Yi,…,Yj,… p11(…,Yi,…)  …  p1p(…, Yj,…))
 …
 …,Yk,… Yj,… pk1(…,Yk,…)  …  pkq(…,Yl,…))))
 Operational semantics:
 If external solver component query returns true on guard
then add to local constraint store constraints in rule body
modulo variable substitution needed to match rule head
with constraints already in the store
 Otherwise try other rules
Transaction Frame Logic:
object-oriented terms
Extends Prolog with object-oriented terms:
 Class definition (hierarchy + signature):
 c1::c2[..., ai *=> ti ,..., mj(tj1,...,tjk) *=>> til ,...].
 e.g.: person[name => string, children(person) *=>> person].
man::person[sex -> male].
• c1 subclass of c2
• ti type of attribute ai of class c1
• til return type of method mj of c1
• tj1,...,tjk parameter types of method mj of c1
 Object creation:
 o:c[..., ai -> vi ,..., mj(vj1,...,vjk) -> vil ,...].
 e.g.: al:man[name -> “Al”, children(ann) -> dan].
• o object instance of class of c
• vi value of attribute ai of o
• vil return value of method mj of o when
invoked with input parameter values vj1,...,vjk
FLOOM:
Frame Logic
Object-Oriented
Molecules
Transaction Frame Logic: high-order
OO syntax and update predicates
 Allows logical variable in any position:
 ?- person[name -> N, children(P1) *->> P2].
 ?- Object:Class[Attibute -> john, Method(Parameter) *->> terry].
 Allows path expressions, similar to OCL navigation expressions:
 ?- person.name = N, person.children(P1) = P2.
 Extends Prolog w/ new, backtrackable update predicates:
 P:person[setAge(A)] :- btdelete{P.age}, btinsert{P[age -> A]}.
ORCAS: component assembly
as rule base composition
Aspect Java Contract Test
Generator Companion
Component for OBNFL
Generic Java
Generic Java
CHRD Base
CHRD Base
Compiler
Verifier
Aspect Java Component for OBNFL:
Object-Oriented
Bayesian Network Full Learning
Object-Oriented
CHORD(BNFL)
Bayesian Network
Rule Bases
Full Learning:
Aspect J CHRD
Structure &
CHORD(BILP)
CHORD(BNPL)
Parameters
Rule Bases
Rule Bases
CHORD(BNI)
Reasoning Explanation GUI
Rule Bases
CHORD(RLEI)
Rule Bases
CHRD(OO(FL))
Rule Base
ORCAS: partnerships
 CT-Info CNPq
 Partners
 Profa. Patrícia Tedesco, CIn-UFPE
 Prof. Luis Menezes, UPE
 Prof. Jones Albuquerque, UFRPE
 Focus
Application case studies to intelligent agent tutoring system
(intersection with IATE), and marine ecology simulation (Simulare
project)
ORCAS: partnerships
 CT-Info FINEP
 Partners
 Profa. Patrícia Machado, Prof. Jorge Figuereido,
Prof. Franklin Ramalho, DSC-UFCG
 Prof. Luis Menezes, UPE
 Jynx Playware (soccer and business simulation game company)
 CESAR
 Focus
 Generation of built-in contract testing components from functional
component
 Automated generation of Transaction Frame Logic programs from UML
and OCL models (as a preliminary step towards generation of CHORD
programs)
 Application case studies to simulation games
ORCAS: partnerships
 CAPES/DAAD PROBRAL
 Partners:





Prof. Silvio Meira, CIn-UFPE
Prof. Luis Menezes, UPE
Prof. Thom Frühwirth and PhD. student Marc Meister, Ulm Universität
Prof. Colin Atkinson and PhD. student Matthias Guthiel, Mannheim Universität
Dr. Armin Wolf, Fraunhofer Gesellschaft Institute FIRST, Berlin
 Focus







Design of CHORD (syntax and formal semantics)
Upgrade of KobrA process to latest OMG standards (UML2, OCL2, MOF2)
Extension of KobrA process to specify GUIs
Adaptation and extension of KobrA process for ORCAS components
CASE tool for KobrA with model checking facilities
First adaptive implementation of CHRD engine (compiled to Aspect J)
Application case study on cost-saving surgery scheduling and allocation in large
hospital
ORCAS: current status and next steps
 Direct collaborators:
 PhD. candidate Jairson Vitorino, CIn-UFPE
 Undergraduate research assistant Marcos Aurelio Silva, CIn-UFPE
 Prof. Luis Menezes, UPE
 Current status:





KobrA model of preliminary, non-adaptive CHRD engine version
Aspect J / Java implementation of the model
Reasoning trace implemented as aspect
First implementation as compiler to Java
Novel, more efficient operational semantics
 Next steps:
 Improve reasoning trace GUI
 Switch from chronological backtracking to conflict-directed
backjumping for disjunctive rule and finite domain labeling search
IATE: Goals
 Build an extensible, fully parametric, multi-agent environment that
can serve as reusable kernel for:
 Multi-Agent System (MAS) and Artificial Intelligence (AI) tutoring
environments;
 MAS and AI controlled experiments environments;
 MAS and AI based team ball sport computer games.
 The environment:
 Simulates a single base domain, a futuristic fusion team ball sport
(rollerslam)
 In all its possible variations in terms of: observability, determinism,
dynamicity, physics modeling granularity, agent communication, as well as
the size and diversity of agent action, agent perception, object and
location sets.
 Evaluate and extend MDA PIM transformation techniques to
automatically generate product line of such environment
Motivation: AI and MAS teaching
MAS Environment
Internal Agent Architecture
Observable environment
Reflex agent
Deterministic environment
Past environment model agent
Continuous environment
Goal agent
Utility agent
Real-time environment
Future environment model agent
Relational environment
Learning agent
Cooperative environment
Knowledge Representation
Ontological commitment
Epistemological commitment
Variable domains
Reasoning Paradigm
Deduction
Belief revision
Abduction
Inheritance
Constraint solving
Analogy
Induction
Motivation: AI and MAS education
 Didactic value of single domain illustrative example problems in
multiple versions at progressive sophistication levels
 Most existing problems:
 Fixed characteristics  relevant to illustrate only a few techniques
 Examples:
Partially observable
Discrete
Deterministic
Sequential
Mono-agent
Ontologically poor
Partially observable
Continous
Non-deterministic
Real-Time
Multi-agent
Ontologically poor
IATE Motivation: AI and MAS
experiments and competitions
 Fully parametric environment ideal benchmark generator to:
 Compare architectures, reasoning paradigms and knowledge
representation languages
 Pin-point which environment characteristics requires switching
technique
 What are the scalability phase transitions
 Current competitions:
 Planning: restricted to very narrow technique and problem sets
 RoboCup: comparing “Cadillacs vs. Dinosaurs”, everything all at once,
no general scientific insight
IATE current status and next steps
 Direct collaborators:
 PhD. candidate Fábio Moura, CIn-UFPE
 New undergraduate research assistant
 Current status:
 Preliminary versions of:
 MAS environment MOF metamodel and UML Profile
 Simplest rollerslam simulation UML model (instance of metamodel)
 Next steps:




More complex rollerslam simulation UML models
Environment characteristics’ UML models
Simulation independent rollerslam UML model
Transformation rules to generate:
 Simplest and more complex rollerslam simulation models
 from simulation independent rollerslam models
 and environment characteristics’ model
 Repeat iteration for soccer simulations
MAS Environment Meta-model and UML Profile