UPML

1
UPML

• UPML - A Framework for knowledge system reuse
• Dieter Fensel, University of Karlsruhe, Germany
  / Free University of Amsterdam, NLV. Richard
  Benjamins, University of Amsterdam, NL
• Enrico Motta, Open University, Milton Keynes,
  UK
• Bob Wielinga,University of Amsterdam, NL

2
Introduction

• What is UPML about
• The backbone of UPML
• UPML Tools
• Conclusions

3
1 What is UPML about

• UPML takes CML of CommonKADS as a starting point
  and
• refines its component model supporting component
  reuse and component-based software development
  and
• makes it machine processable to enable
  semiautomatic system development.

4
2 The Backbone of UPML
PSM
Task
Refiner
Refiner
PSM-Task
Task
PSM
Bridge
Ont.
Refiner
Task-Domain
Ontologies
PSM-Domain
Bridge
Bridge
Domain Model
5
2.1 Ontologies

• An ontology provides an explicit specification of
  a conceptualization which can be shared by
  multiple reasoning components.
• Ontologies provide the definition of signatures
  and axioms that are used by the other parts of
  the architecture.

6
2.2 Tasks

• The task specifies the problem that should be
  solved by the knowledge-based system.
• Contrary to most approaches in software
  engineering this problem definition is kept
  domain independent, which enables the reuse of
  generic problem definitions for different
  applications.

7
2.3 Domain Models

• The description of the domain model introduces
  domain knowledge as it is required by the
  problem-solving method and the task definition.
• It consists of three elements characterization
  of properties, assumptions, and the domain
  knowledge itself.

8
2.4 Problem-Solving Methods

• Problem-solving methods describe which reasoning
  steps and which types of knowledge are needed to
  perform a task.
• UPML distinguishes two different types of
  problem-solving methods
• complex problem-solving methods and
• primitive problem-solving methods.

9
2.4 Problem-Solving Methods

• Complex problem-solving methods decompose a task
  into subtasks.
• Primitive problem-solving methods make
  assumptions about domain knowledge to perform a
  reasoning step. They do not have an internal
  structure.

10
2.5 Bridges

• Bridges explicitly model the relationships
  between two distinguished parts of an
  architecture, e.g. between domain and task or
  task and problem-solving method.

11
2.6 Refiners

• Refiners can be used to express the stepwise
  adaptation of elements of a specification, e.g. a
  task is refined or a problem-solving method is
  refined

12
2.7 Design Rules

• Architectural constraints ensure well formed
  specifications.
• The individual components must fulfill certain
  properties.
• Their connection via bridges and refiners must
  fulfill certain properties.

13
2.8 Guidelines

• Development guideline structure the process of
  developing a system models.
• A process model with defined transitions helps to
  navigate through the space of possible system
  designs.

14
3 UPML Tools

• Editor for UPML
• Verifier for UPML
• Browser for UPML

15
3.1 Editor for UPML

• PROTEGE-II provides an environment for realizing
  knowledge accquisition tools.
• We used PROTEGE-II for defining the meta ontology
  of UPML and
• for realizing an editor for UPML.

16
3.1 Editor for UPML
17
3.1 Editor for UPML
18
3.2 Verifier for UPML

• KIV is an interactive theorem prover for
  modularized software.
• The architecture of UPML can be expressed within
  the module concept of KIV.
• Automatic generation of proof obligations.
• Interactive proof process with open
  goals(Inverse Verification).

19
3.3 Browser for UPML

• We used On2broker as a browser and query
  interface for UPML specifications.
• We had to develope a translator from CLIPS to
  Frame logic.
• Query Interface is a JavaTM Remote Method
  Invocation (RMI) Server which can be consulted by
  any software agents.

20
3.3 Browser for UPML
21
4. Conclusions

• What have we achieved in phase one?
• A meta-ontology for describing knowledge-based
  systems, which is
• a conceptual and formal standard for describing
  knowledge-based systems ...
• ... which are built up from reusable components.

22
4. Conclusions

• What will we do in phase two?
• Better integration of tool environment
• Better integration in existing software standards
  like UML and MOF/CORBA.
• Refinement of the process model.
• Spin off applications.