welcome: please sign in

Revision 9 as of 2010-11-14 15:12:58

Clear message
location: oro-server

oro-server.png

Introducing ORO, the OpenRobots Ontology cognitive kernel

oro-server (or, in short, ORO) is a Java-based knowledge base for cognitive robotic applications. It is developped at the LAAS-CNRS, France and IAS-Technische Universität München, Germany by Séverin Lemaignan (severin.lemaignan@laas.fr)

This page introduces the OpenRobots Ontology server ideas and features. The complete, up-to-date developers' documentation of oro-server can be found here.

Informations on this page are based on oro-server 0.7.2, as of February 2010.

1. Summary

2. What is ORO

2.1. Introducing a cognitive layer

Robots interacting with complex, human-inhabited, environments are expected to exhibit advanced cognitive skills: objects recognition, natural language interactions, task planning with possible dynamic replanning, ability to cooperate with other robots or humans, etc.

These functions, while being scientific challenges partially independent from each other, need to communicate, and thus to share a common representation of concepts of the world, to be effectively combined in a complete, autonomous, robotic system.

The oro-server project focuses precisely on the implementation of such a common description framework, along with a library of basic, reusable cognitive functions. This so-called cognitive kernel is actually build as a server that maps cognitive service to a ontology-based backend.

Amongst other features, these base cognitive functions include:

oro_architecture.png

In practical terms, oro-server does mainly two things:

It relies on RDF/OWL ontologies to represent an store knowledge and runs several active processes that offer, amongst other things, reasonning facilities, support for bio-inspired memory models, concepts of "cognitive events", categorization and explicit modeling of other agents.

Planned features include reinforcement learning, pro-active "curiosity" and mechanisms to handle cognitive conflicts (ie inconsistent chuncks of knowledge).

2.2. What can it be used for?

Upon these bricks, it possible to build semantic-aware layers and applications.

At the system level, such a cognitive kernel allows:

laas_current_semantic_scenarii.png

At the application level, ORO enables to built semantic and context-aware components. Example of applications include:

[LIST TO BE UPDATED]

3. Installation

3.1. Via robotpkg

The supported way to install oro-server is through robotpkg:

> cd $ROBOTPKG_BASE/knowledge/oro-server
> make update

3.2. From the sources

You can grab a snapshot of the sources on the public FTP: ftp://softs.laas.fr/pub/openrobots/oro-server/

Or, to get the latest version of oro-server, you can check-out the sources with GIT:

> git clone http://softs.laas.fr/git/robots/oro-server.git

To run the ontology server, you'll need Java JRE >= 1.6. The two only dependencies of oro-server are on Jena >= 2.6.2 and Pellet >=2.0.

By default, the Makefile expect following paths for these library:

$PREFIX/java/jena/lib
$PREFIX/java/pellet/lib

You can override these defaults by setting the $JENA_LIBS and $PELLET_LIBS with your custom paths.

You can then compile it with:

> cd oro-server
> make PREFIX=[your prefix] install

> make PREFIX=[your prefix] install-doc

If everything went fine, a executable script called oro-server should have been created in $PREFIX/bin.

Before starting the server, you can tune the options in $PREFIX/etc/oro-server/oro.conf. In particular, check the path to the ontology you want to load is correctly set up. If you don't have yet any ontology to play with, grab a fresh (January 2010) snapshot here or check the OpenRobotsOntology page on my Wiki.

4. The OpenRobots Common Sense ontology

The knowledge that the robot acquires need to be somehow connected to other chunks of knowledge to become actually useful (enabling inference, contextualisation, efficient querying, etc.). This requires a common-denominator for the overall knowledge structure: users of the knowledge base must agree on common identifiers to symbolize identical concepts. This is provided by a "upper" common-sense ontology that can be loaded at the server startup.

The common-sense ontology has its own page: OpenRobots Common Sense ontology.

5. oro-server features

5.1. Alterite module

5.2. Categorization module

             +-------+
             | Thing |
             +--,'.--+
             .-'   `-.
           ,'         `.
         ,'             `-.
      .-'                  `.
+----+--+                 +--+-----+
| Plant |                 | Animal |
+---+---+                 +--+++---+
    |                   _,-"  |  `--.._
    |                .-'      |        ``--..
  plant1         animal1    animal2        animal3
    |               |         / `.            \
    |               |        /    `-.          \
 hasColor         eats     eats  hasColor   hasColor
    |               |        |      |          |
    |               |        |      |          |
  green          banana    grass   blue       red

If the robot wants to answer an ambigious order like Give me the thing!, it needs a way to disambiguate the different possible individuals in the Thing class.

More details on the Categorization module and its algorithms here.

5.3. Events module

Events are triggered by so-called Watchers

A watcher stores the type of event (cf below) along with the pattern (the form of the pattern depends on the type of event).

Following type of events are currently implemented:

5.3.1. FACT_CHECKING

5.3.2. NEW_INSTANCE

5.3.2.1. Example

 > registerEvent
 > NEW_INSTANCE
 > ON_TRUE
 > b
 > [?a desires ?b, ?a rdf:type Human]

 > add
 > [ramses rdf:type Human, pyramidInauguration rdf:type StaticSituation, ramses desires pyramidInauguration]

 > event
 > [pyramidInauguration]

5.3.3. NEW_CLASS_INSTANCE

The event is triggered when a new instance of the class returned by the watch pattern is added. When the event is fired, the server send to the client the list of the new instances. This kind of event is a special, optimized version of NEW_INSTANCE for class instances.

5.4. Memory module

The "Memory module" provides a memory management system that allows the robot to forget about facts after a while. Reinforcement learning is planned but not yet implemented as of December 2009.

6. Interfacing with ORO

ORO offers numerous way to interface, either through direct socket connection, language-specific bindings or robotics middleware abstractions.

The documentation is available on this page: Interfacing with ORO.

7. Extending ORO

Since version 0.7.2, it's very easy to extend ORO with you own plugins.

A complete tutorial is available on this page: Writing plugins for ORO.