RUBYCON: Concept Processing Toolkit

Ben Bongalon
May 21, 2005

---

Main | User Guide | Download

NEWS UPDATE

05/21/2005	Online documentation for RubyCon has been updated. In particular, the install instructions for the source distribution have been fixed. Added navigation links to pages. Source code has not changed.
08/11/2004	RubyCon v0.8 is released. This is the first publicly-available version.

 

 

 

 

What is RubyCon?

RubyCon is an open-source, rapid development toolkit for building concept processing and other intelligent reasoning systems. RubyCon builds upon the work of the ConceptNet project [1], implementing ConceptNet’s semantic network of 280,000+ assertions and graph-processing algorithms into a set of reusable objects in the Ruby programming language[2].

Ruby is a dynamic, object-oriented language that serves as an ideal medium to try out your cool AI ideas, but also as the “glueware” to loosely integrate technology components from various sources including lexical databases, knowledgebases, inference engines, etc. Using the Ruby shell interpreter, you can interactively inspect and change the ConceptNet objects and develop code modules to incrementally build a more intelligent system. This evolutionary system development approach offers a practical and promising way to reach the Holy Grail of AI: to craft a machine with intelligence that can reach or surpass human-level performance[3].

Key Benefits and Features

The latest release of RubyCon comes with the following features and functions:

• Includes over 170,000 node concepts and 280,000 assertions (called “links” in ConceptNet) as the baseline knowledgebase
• Support for knowledge-level operations [4] on assertions and concepts. You can easily add or delete facts in the knowledgebase using assert() or retract() respectively. For concepts, RubyCon provides the functions create(), fetch() and delete().
• Retrieve assertions using powerful pattern-matching expressions. For example to find out what the system knows about monkeys, you use the command: match ["Do", "monkey", /eat/]
• Add/Delete assertions and concepts
• Concepts and assertions are stored in database files, allowing user changes to be permanently saved
• Retrieve a concept by name or semantic ID
• Find assertions that refer to a concept (forward and backward links)
• Find a path between any two concepts

In addition, the Ruby language and programming environment offers many capabilities including:

• Interactive shell scripting environment for easily implementing and debugging machine intelligence features
• Expressive and abstraction power comparable to LISP without the hassle of nested S-expressions (ie, no more putting up with (deeply (nested (parentheses)))
• Extensive set of built-in constructs: regular expressions, pattern matching operations, iterators, association lists, hash tables, dynamic arrays, etc.
• Automatic memory management through garbage collection
• Support for advanced programming techniques such as runtime evaluation of code, reflection, marshalling, closures (continuations in Scheme parlance), ability to dynamically modify objects/classes/methods
• And much more…
  

Platform Support

RubyCon is developed and tested on Windows XP but should work with little or no modification on other platforms where Ruby is installed including Windows 9x/NT/2000, OS X, Linux.

If you are not using the RubyCon Windows-binary distribution, you must first rebuild the concepts and assertions databases. This step is needed since Ruby stores the databases in native (ie, platform specific) file format. Instructions to rebuild the databases can be found in the User Guide.

Installing and Using RubyCon

See the User Guide for step-by-step instructions.

Bugs and Limitations

The current release only partially implements the set of graph algorithms available in ConceptNet and does not have a Graphical User Interface. In addition the RubyCon FindPath() function runs noticeably slower than other implementations. This may be due to the performance penalty introduced by using an interpreted language, or because of implementation differences (RubyCon uses a depth-limited search algorithm [5]). These issues should be fixed in subsequent releases.

Please send bug reports, questions or comments to:

Author’s Comments

I developed RubyCon to explore how commonsense reasoning behavior can be teased out from a semantic network of knowledge assertions. As such, only the ConceptNet features that are most essential for testing my theories have been implemented.

In addition I extensively reengineered the original ConceptNet design in order to understand more clearly how it works, at times sacrificing fidelity to the original design for simplicity and/or ease of implementation. For example the CMapLink structure was replaced with a simple (and built-in) dynamic Array. Despite these differences, I hope that you will find RubyCon useful.

Help Wanted

I would appreciate your feedback, suggestions or words of wisdom/encouragement :-)  If you are interested in contributing to this project, please contact me.

Some immediate things that can be done to make RubyCon more useful are:

1. rebuild the RubyCon concept and assertions databases in other platforms (eg, OS X, Linux) so that they can be made available for download
2. implement the other ConceptNet functions: FindContext(), FindAnalogous()
3. figure out how to speed up FindPath()
4. expand the documentation by describing the API and creating a tutorial
5. adding a Graphical User Interface
   

--------------------------------------------------------------------------------

[1] The ConceptNet commonsense reasoning toolkit (also known as "OMCSNet") is a project from MIT: web.media.mit.edu/~hugo/conceptnet/

[2] You can find out more about Ruby at www.ruby-lang.org

[3] Note on how to build AI systems with human-level performance. This part is left as an exercise for the reader.

[4] Following Allen Newell's approach, RubyCon provides functions for working with concepts and assertions in a way that hides the implementation details. See http://www.cc.gatech.edu/~jimmyd/summaries/newell1982.html for one definition of "knowledge level".

[5] The depth-limited search algorithm is described in AI: A Modern Approach (2nd Edition) by Stuart Russell and Peter Norvig.