Getting Started with Atoms and the Scheme Shell

From OpenCog
Jump to: navigation, search

Theory


The links above provide detailed descriptions of all topics in this chapter. What follows is a severely restricted selection from these pages. One should go back and explore those links to gain a deeper understanding of the topics introduced here.

Atomspace

Atomspace is a Knowledge Representation (KR) database and the associated query engine that is used to manipulate the data it stores. Data is stored in the form of hypergraphs. A graph is a collection of vertices (nodes) and edges (links), in which each edge connects two vertices. A hypergraph is a graph in which each edge can connect an arbitrary number of vertices. In Atomspace the vertices and edges are collectively called Atoms. So the Atomspace has hypergraphs that are made up of Atoms.

Atoms, Links and Nodes

Each Atom has a set of properties associated with it. Based on these atoms are classified into Links and Nodes.

Nodes: These are uniquely identified by the combination of name and type. So no two Nodes in an Atomspace can have both the same name and the same type. These atoms correspond the the vertices in the hypergraph.

Links: Links are uniquely identified by the combination of outgoing set(the atoms it points to) and type. These correspond to the edges in the hypergraph.

Practise

Making some atoms (scheme)

Scheme is a dialect of lisp. Lisp is a programming language from the days of yore. Now before you pack up and move to the python section, it is a really fun language. And learning it --at least for what you need to do in this section-- is easier than even python.

1. Starting the scheme shell: If you installed everything correctly then you should be able to open a scheme shell by typing guile in your terminal.

$ guile
GNU Guile 2.0.9
Copyright (C) 1995-2013 Free Software Foundation, Inc.

Guile comes with ABSOLUTELY NO WARRANTY; for details type `,show w'.
This program is free software, and you are welcome to redistribute it
under certain conditions; type `,show c' for details.

Enter `,help' for help.
scheme@(guile-user)> 

2. Loading opencog: Before we can start playing with Atoms we need to load the opencog modules in the scheme shell we just opened. To do this you need to type the following:

scheme@(guile-user)> (use-modules (ice-9 readline)) (activate-readline)
scheme@(guile-user)> (add-to-load-path "/usr/local/share/opencog/scm")
scheme@(guile-user)> (add-to-load-path ".")
scheme@(guile-user)> (use-modules (opencog))
scheme@(guile-user)> (use-modules (opencog query))
scheme@(guile-user)> (use-modules (opencog exec))

You can put this in your ~/.guile file (create one if none exists) to avoid typing this every time.

$ vim ~/.guile
(use-modules (ice-9 readline)) (activate-readline)
(add-to-load-path "/usr/local/share/opencog/scm")
(add-to-load-path ".")
(use-modules (opencog))
(use-modules (opencog query))
(use-modules (opencog exec))

You can also put these commands at the top of any .scm file and then run it by typing:

guile filename.scm

3. Creating Atoms(Nodes): At the scheme prompt you can create a ConceptNode by typing:

scheme@(guile-user)> (ConceptNode "HelloWorld")
$12 = (ConceptNode "HelloWorld")

There are several types of Nodes that you can create using a similar syntax. For an exhaustive list see this page. All nodes can be created by specifying a name and a type. When you create a node this way it is added to the atomspace that is automatically created when we load opencog in the scheme shell.

4. Creating Atoms(Links): Since Links are identified by their type and their outgoing set, we create them by specifying those two attributes.

scheme@(guile-user)> (InheritanceLink (ConceptNode "Fox") (ConceptNode "Animal"))
$13 = (InheritanceLink
   (ConceptNode "Fox")
   (ConceptNode "Animal")
)

Here the type of the link is InheritanceLink and the outgoing set consists of two ConceptNodes named "Fox" and "Animal" respectively. Again there are several types of links and you can look at the exhaustive list at the same page.

5. Querying the atomspace: Till now we have added Atoms to the Atomspace. This amounts to adding knowledge/data in the KR database. Now we will take the next step and do something with that knowledge/data. Let us start by just adding two numbers.

First we add two numbers to the Atomspace.

scheme@(guile-user)> (define num1 (NumberNode 3)) 
scheme@(guile-user)> (define num2 (NumberNode 5))

Now, we add a procedure in Atomspace that knows how to add the two numbers.

scheme@(guile-user)> (define link (PlusLink num1 num2))

Finally, we use the function cog-execute! to run this procedure. (More about this in the next section).

scheme@(guile-user)> (cog-execute! link) 
$19 = (NumberNode "8.000000")

Quiz

1. What is Atomspace?

According to Plato, its a theoretical space of all atomic types, a periodic table if you will, where all material derive from these five fundamental atomic types: earth, water, air, fire, and the proposed 5th element which Plato postulated must exist which Aristotle later called 'ether'.
A modern metaphysical construct representing the basic building blocks of the material universe.
Knowledge Representation database and the associated query engine that is used to manipulate the data it stores.
Atom Ant's hideout.

2. What is a Node?

A form of hypersonic vaccumous awl used by the galactic federation of machine elves to rescue the operating thetan scientologists from vengeful volcanic utility fog.
An extremely blocked nose - which makes it really hard to pronounce the letter 's', making it instead sound like the letter 'd'.
These are uniquely identified by the combination of name and type. So no two Nodes in an Atomspace can have both the same name and the same type. These atoms correspond the the vertices in the hypergraph.
An open-source, cross-platform JavaScript runtime environment for developing a diverse variety of tools and applications.

3. How are links identified?

Ask yo mother.
By querying the hypergraph, selecting for the unique identifiers of the nodes between which the links operate, and applying a 'having' clause which selects for and projects the identified link.
By the combination of the outgoing set (the atoms it points to) and type (which correspond to the edges in the hypergraph).
By typing '(cog-bind deduction-interface-rule)'.
By typing '(cog-bind deduction-inherit-rule)'.

4. Scheme is a dialect of ....

Python
C
Lisp
Visual Basic
Guile

5. How do you enter the scheme shell?

type 'Scheme -lxe'
click on the shortcut marked 'scheme' on your windows desktop
type 'help' and hope for the best
type 'guile'
type 'vim ~/.guile'

Your score is 0 / 0