There’s a new ‘pln fc’ command, in the CogServer shell, which runs some FC inference.

Here are some pics of the new forward chainer on a demo dataset about toys, object persistence etc. They show the atomspace before and after inference.

Following is a general explanation of how it works. The idea is that each PLN Rule can provide templates for the Atoms it requires as input. In each inference step, the forward chainer picks a Rule, and then looks up a sequence of
Atoms that match the input templates.

Here’s an example with DeductionRule, solving the classic “Mortal Socrates” problem, explained on the OpenCog wiki.

DeductionRule requires two Atoms, in the form:

(Inheritance A B)
(Inheritance B C)

which basically means, A is a B and B is a C. It then produces:

(Inheritance A C)

For the first argument, the forward chainer looks up any Atom that matches (Inheritance A B), that is, any InheritanceLink in the system.
Suppose it finds “Socrates is a man”:

(Inheritance Socrates man)

Now it has A = Socrates and B = man. So to find the second argument, it looks for:

(Inheritance man C)

i.e. “man/men is/are <something>”. Suppose it finds “Men are mortal”:

(Inheritance man mortal)

Then it feeds these two premises into the DeductionRule, which produces:

(Inheritance Socrates mortal)

Remember that since this is forward chaining, it could have found all sorts of other things. If it had found, for the second argument, “Men tend to be bald”, then it would have produced “Socrates is probably bald”

BIT visualizer

In my opinion, the BIT visualiser shows great promise as a tool for understanding the complexities of BIT expansion. In particular, the cross joins between sub-trees make it much clearer how sharing of sub-trees is occurring. The size of the BITNodes reflect their fitness evaluation in determining which node of the inference tree will be expand next and will inevitably be useful when we get to the stage of tuning the the fitness heuristic.

Being a prototype, there is plenty of scope for continued development, a couple of the many ideas that immediately come to mind are:

• expansion of BITNodes by clicking on them (this would require OpenCog to provide an XML-RPC interface first however), and
• thematic colouring of rules so that it’s easier to distinguish between the subtrees.

This is part of the bigger challenge of general AtomSpace visualisation. How do we convey knowledge about the processes that are going on in a digital mind to humans in a meaningful way?

These experiments don’t use the indefinite probability formulas but rather the good old fashioned SimpleTruthValue PLN formulas.

What they involve is using PLN to extrapolate indirect word associations, from direct words associations mined from text (by some statistical text mining software created for OpenCog by Linas Vepstas).

This obviously does not stress the generality of PLN as an inference framework (no VariableNodes! no quantifiers! no intension! no fuzzy MemberLinks!).  There is nothing particularly revolutionary AI-wise here … it’s just some fairly straightforward, state-of-the-art statistical NLP … Hebbian learning on a neural net, among many other techniques, could do basically the same thing … but this is a reasonable “smoke test” of the ability to load a bunch of nodes and links into OpenCog and perform some basic inference processes on them.  One nice point about PLN is that it can handle relatively simple, associative-neural-netty stuff like this, as well as more complex reasoning involving variables and quantifiers and such, all seamlessly within the same mathematical, conceptual and software approach.

The reason I decided to write a blog post on this is that Joel produced some nifty pictures based on his work, using the open-source graph visualization package Tulip.

Here is a big nasty network of nodes and links in OpenCog, before inference:

Here is the same network, after some first-order PLN inference, with the inferred links in green:

Obviously the above don’t tell you too much.  Tulip was configured so that nodes representing more greatly similar words (in terms of their statistical association) would generally be placed closer together in the visualization.  Slightly more insight is given by zooming in, using Tulip, to see some of the nodes and links close up.  Again, the links in green are the products of inference:

Note that in the immediately above example, to build the associative link between “foreign” and “administration” requires the system to make two inferences in sequence: