Bag of Souls

Easily installing clojure and vimclojure using leiningen

Wed, 21 Jan 2009 09:57:00 +0100

These are the steps I follow to install a local working environment (as you can guess this post is more as a mental note for me, so I can remember what I have done).Make a local bin directory.
mkdir ~/bin
cd ~/bin

Get Leiningen, and self-install it.
wget http://github.com/technomancy/leiningen/raw/stable/bin/lein
chmod +x lein
lein self-install

Make a project directory, for example 'eden-3'
mkdir ~/eden-3
cd ~/eden-3

Make a project.clj file in ~/eden-3, detailing the dependencies



(defproject eden-3 "1.0.0"

              :description "My own project"

             :dependencies [[org.clojure/clojure "1.1.0-alpha-SNAPSHOT"]

                             [org.clojure/clojure-contrib "1.0-SNAPSHOT"]

                             [dk.brics.automaton/automaton "1.11.2"]]

              :dev-dependencies [[org.clojars.ato/nailgun "0.7.1"] 

                                 [org.clojars/gilbertl/vimclojure "2.1.2"]]

              :main eden)

Make a src directory in ~/eden-3, and write the sourcecode of eden.clj in that directory



(import '(dk.brics.automaton Automaton RunAutomaton RegExp))

(RegExp. "[123][12][13]")

Auto-install the dependencies, as specified in project.clj
cd ~/eden-3
lein deps

Unpack the nailgun client and vimclojure vim scripts somewhere, and manually install them
mkdir ~/temp
cd ~/temp
wget http://www.vim.org/scripts/download_script.php?src_id=11066
unzip vimclojure-2.1.2.zip
cd vimclojure-2.1.2
mkdir ~/.vim
cp -r autoload ~/.vim
cp -r doc ~/.vim
cp -r ftdetect ~/.vim
cp -r ftplugin ~/.vim
cp -r indent ~/.vim
cp -r syntax ~/.vim
cd ngclient
make ng
cp ng ~/bin

Setup your .vimrc



set nocompatible

filetype plugin indent on

syntax on



let maplocalleader = ","



let g:clj_highlight_builtins = 1

let g:clj_highlight_contrib = 1

let g:clj_paren_rainbow = 0

let g:clj_want_gorilla = 1



let vimclojure#NailgunClient = "/path/to/your/ng"



set number

set hidden

set showmode

set bs=2

And you're ready to go. Just fire up the nailgun server manually, open the sourcecode in vim, and launch a repl with ",sr"
cd ~/eden-3
java -server -cp 'src:classes:lib/*' com.martiansoftware.nailgun.NGServer 127.0.0.1 &
vim src/eden.clj

Done!

Choice-based wandering

Wed, 04 Jun 2008 08:28:00 +0100

I've written about different wandering algorithms in one of the sidetrack posts, but now it is time to decide and design an algorithm by which the craas move around. There's several that spring to mind. The first, and perhaps most well-known one is to separate the field of vision of a craa in three regions (left, right, forward), and let it navigate to the region which is the most attractive.Extensions of this three-field method would include more fields (closeby, far away), so that a tiger far away isn't taking precedence over quenching the craas' thirst at this water pool right now. A simplification of the fields algorithm would be to consider a single, circular field, and sum up all the vectors from all the impulses to obtain a direction.

There is different ways to sum up. We could weight different impulses based on the strength of the emotions associated with them, and on the distance they are away from us. More complicated, you could also weight them on whether or not they are expected (using the craas memory to create an image of what is expected) and give special weight to unexpected things. The latter puts us into a little bit of trouble though.. what if a craa expects a lion to charge him and thus pays no attention anymore.

Summing impulses can put you into a classical bit of trouble called Buridan's ass, which actually occurs in reality (although not neccesarily in donkeys), so we will have to see if the artifacts of a summing system are acceptable.

One thing I do want is that next to perhaps weighting based on distance, weighting based on the current needs of the craa. How needs are managed and created will be the topic of another post.

Wandering Algorithms

Fri, 16 May 2008 20:43:00 +0100

In a previous weblog, I had started to work on different algorithms by which craas could steer themselves through empty space. Spending time on this now seems something like a folly to me, as the algorithm I use now lets the animal steer themselves based on previous experiences. There is still some use in the older algorithms, for example if a certain group of animals isn't your focus of interest, and you just want to have them move around in your artificial world. I'll describe the different algorithms I used here, and refer to some of the literature.

Part of them are in ruby / OpenGL (the previous language / graphics engine I used), and part of them are described in words.There are many many ways you could device a wandering algorithm, the most simple being perhaps the venerable random walk in which your entities are randomly moved into one of the available directions.

The biological equivalent for animals of the random walk is the forward random walk (although it might often be called different). Its basic rule is that animal moves forward, and occasionally shifts into a random new direction.

If turning at straight angles is not what you seek in your artificial life, then you can smoothen the angles in a random forward walk pattern by limiting the number of degrees your animals can turn in a single timestep. A few timesteps after a direction change, they'll have turned enough to be again aligned with the direction they were aiming for. An example of this algorithm, and how it looks is given below. The full code of the program is at the bottom of the page.

#smoothed random forward walk

#

@aim = rand(360) if rand < 0.001

@angle = ((250 * @angle + angle_diff(@angle,@aim)) / 250.0) % 360

A variant on the smoothed random forward walk is to let the direction of the animal change slightly every single timestep, rather than having a large change in direction ever so often. This approach doesn't have the straight lines of the random forward walk algorithms, and might be something you desire when you design a wandering algorithm.

# wandering aim forward walk

#

# if the difference between the direction (angle) of the bird and its goal (aim) is

# larger than 6 degrees, then the bird corrects for it (but slowly by 1-200th)

diff = angle_diff(@angle,@aim).abs

if diff > 6 then @angle = ((200 * @angle + diff) / 200.0) % 360 end

# the aim is drifting randomly between 0 and 360 degrees

@aim += 3 * (rand(3) - 1) #33% chance of not changing

@aim = @aim % 360

With these small alterations you can device a large number of wandering algorithms, but the these algorithms are mainly suitable for slow-moving animals, which do not experience inertia; for animals that always move at a constant speed; or for some obscure reason, houseflies which tend to ignore physics and just turn at straight angles while buzzing around ;). If we add inertia and a variable moving speed, then we get behaviour which seem suitable for modelling animals that chase each other, or move fast in general (like birds).

# acceleration/inertia random forward walk

#

# Every 700 timesteps pick a random direction, translate it to a vector, and

# make sure that the amplitude of the vector is between 0.5 and 1, so that

# the bird isn't flying at snail speed

# (this example isn't really clear code-wise, apologies)

if @passedsincelast > 700

           begin

              @accel  = rand(360).to_vector 

              end until @accel[0].abs > 0.5 and @accel[1].abs > 0.5          

           @passedsincelast = 0

        end



        # moving

        @vector[0] = (1000 * @vector[0] + @accel[0]) / 1001.0  # I'm not sure if it is still acceleration

        @vector[1] = (1000 * @vector[1] + @accel[1]) / 1001.0  # when I describe it like this. it's more like a new vector

Hanno Hildenbrandt, of the university of groningen, netherlands, has been doing something similar (but far more impressive) as this acceleration/inertia algorithm, by applying these basic physics, as well as gravity to a 3d swarm of flocking sterling birds, and combined these physics with crowd behaviour of large swarms of entities, as was previously done by the boids of Craig W. Reynolds.

The code for the three ruby programs is included here:
first and second:

third:

Task 1: associating food with foodsources

Mon, 12 May 2008 13:26:00 +0100

With the memory and the world in place, it is time to subject one craa to its first task: to learn in a field of objects that tree-objects and food-objects are associated (i.e., in their world food lies always adjacent to a tree, and poisonous plants always grow near rocks). The animal is not steering itself yet, but is forced in a random forward walk, and biting whatever it encounters.It works! Given the world (part of it) pasted below, and the craa (@) wandering a 1000 steps, it has clearly associated (f)ood with (T)rees and (p)oison with (R)ocks. Not only that, but in this randomly created world. (N)eutral objects happen to be a lying close to food as well, and are associated as such. The references to (bite X) in the associative memories are actions of the craa it self, which also get added to the short-term memory as they occur, but this will only be interesting in the future, when craas have multiple actions to chose from.



. . . . N . . . . . . . . . . . p R . . . . . . . . . . . . . . . . .

. T f . . . . . . f T . . . . R . . . . . . . . . . . . . . . . . . .

. . . . . . . . . f . . . . . . N . . . . . . . . . . . . . . . . . R

. . . . . . . . . . . . . . N . . . . . . . . . . . . . T f . p . . 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . R p . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p . . . 

N . . . . . N . . . . . . . . . . . . . . . . . . . . . . . . . . . 

. . . . . . N N . . . . . . . . . . . . . . . . . . . . . . . . . . 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . N 

. . . . . T . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . N . f . . . N . . . . . . . . . . . . . . . . . . . p R p .

. . . . . . . . . . . . . . . . . f . . . . . . . . . . . . . p N . .

. . . . . T . . . . N . . . . . . . T . . . . . . . . . . . . . . . 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . f . . . 

. . . . . . . . . . f T . . . . . . . . . . . N . . . . . . . . . T 

. . . . . . . . . . . N . . . . . . . . . . N . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 

N . . . . . . . . . . . . . . . . . . . . . . N . . . . . . . . . . .

. . . . . . . . . . f . . . . . . . . . . . . . . . . . . . . . . . . . 

. . . . . . . . . T . . . . . . . . . . . . . . . . @ . R . . . . .

. . . . . . . . . f . . . . . . . . . . . . . . . . . . . . . . . . . . 

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

The settings in this simulation were: 1000 timesteps, world of 40x40, short-term memory size of 7, long-term memory size of 50, 3 associations made each time an observation is transferred from short to long-term memory.



short-term memory:

(T f N f T f f)



associative longterm memory:

       N  iaw    . N,   4 R,  20 T,  25 f,   . p,   1 (bite N),   . (bite R),   . (bite T),   . (bite f),   . (bite p), 

       R  iaw   16 N,   . R,  10 T,   2 f,  20 p,   1 (bite N),   . (bite R),   . (bite T),   . (bite f),   1 (bite p), 

       T  iaw   23 N,   2 R,   . T,  24 f,   . p,   . (bite N),   . (bite R),   1 (bite T),   . (bite f),   . (bite p), 

       f  iaw   25 N,   1 R,  21 T,   . f,   . p,   1 (bite N),   . (bite R),   1 (bite T),   1 (bite f),   . (bite p), 

       p  iaw   24 N,  19 R,   3 T,   4 f,   . p,   . (bite N),   . (bite R),   . (bite T),   . (bite f),   . (bite p),

If we want our craa to walk on its own, rather than be forced in a walk, it will need a motivation to chose a direction. It will need to be able to give an emotional positive value to food, and control its direction of walking based on the emotional value of a direction. The first attempts to implement this were to merely add these emotions as observations to the long-term memory, but this seemed to have some drawbacks (for one, if a craa had learned about poison, and would just pass by poisonous plants and avoid biting in them, the negative emotion associated with eating poisonous plants would slowly fade from its long-term memory, as it wasn't reaffirming that emotion over time anymore). A second option was to create a separate emotional longterm memory, in which positive, neutral and negative associations with certain objects or actions are stored, and this, for now, seems a more fruitful approach.

Here is the arc code:

~bOR_

The name of the beast

Tue, 12 Feb 2008 17:20:00 +0100

Decided on a name for my artificial animals. Up to now I was calling them boids (after Reynolds work on flocking birds), critters (after my original professors work), and half a dozen other names, which gets confusing after a while. From now on, a single one of them will be a cra, and multiple ones will be referred to as craas.

Artificial life has been given many different names before, and I will try to maintain a species-name list here of artificial lifeforms.First, the origin of craas: It is a reversal of an abbreviation of ARtificial Critters. As the code is written in Arc that name would have been confusing. The reversed word 'cra' sounded more as a species of animals, and happened to be part of the word Simulacra

Earlier artificial lifeforms were named:

Boids - 1987 Craig W. Reynolds The original boids paper
Digital Organism - 1992 Thomas Ray, An approach to the synthesis of life, In: Langton CG, Taylor C, Farmer JD, Rasmussen S (eds). Proc. of Artificial Life II, p. 371. Addison-Wesley
Critters - 2001 Paulien Hogeweg Computing an organism: on the interface between informatic and dynamic processes
more to be added.

Link to similar work:
http://www.msu.edu/~pennock5/research/EI.html
history:
http://devolab.cse.msu.edu/software/avida/background.php

Memory

Wed, 23 Jan 2008 22:18:00 +0100

Memory of the critters will be a fairly simple thing to start with. The short term memory can be imagined as a simple tube, in which the experiences of the animal are entered on one side, and slowly shoved through the tube as more new experiences are added. Experiences come in three forms: observations, actions (your own), effects (for example, a change in your energy state).At a fairly early point in life the tube will be full, and experiences will `fall out' of the tube at the other side. These experiences are stored into the long-term memory of the critter, and as they are stored, they associate themselves with a few of the experiences that are currently in the short-term tube.

Later on, when the animal encounters an experience for which it has a memory, this memory will also give the animal acces to some predictions about what is going to happen next. what actions it performed in the past, and what effect these actions had. This (hopefully) is enough for the animal to make an informed decision.

More details on the memories: if an animal experiences something again, the memory already carries with it a number of associations (3 in the example), but in total has room for a predefined number of associations (current default is 50). These associations are randomly overwritten. As a result, those experiences that often follow after a particular memorized experience will occur more frequently in the array of associations that comes with the memory. Therefore, the frequency with which something is associated with a particular memorized experience provides a mechanism by which multiple responses to a particular experience can co-exist with different `weights' each.

One possible future extension is not to pick random associations, but to increase the chance on associations that are temporally closer to the oldest one (a poisson distribution).

Codewise, the implementation is as follows



(deftem creature 

   stm nil

   stmsize 7

   ltm (table)

   ltmsize 50

   s2ltm 3)



(= creature (table))

(= (creature "ltm") (table))



o = observation, i = the memory to be stored, stm / ltm = short / longterm memory.

(def add-observation (creature o)

   (= creature!stm (cons o creature!stm))

   (let i (car (nthcdr creature!stmsize creature!stm))

      (if i

         (do

            (if (no (creature!ltm i)) (= ((creature 'ltm) i) (n-of creature!ltmsize nil)))

            (repeat creature!s2ltm

               (let stm-pp (rem i (rem nil creature!stm))

                  (if (~is 0 (len stm-pp))

                     (= ((creature!ltm i) (rand 50)) (car (nthcdr (rand (len stm-pp)) stm-pp))))))

            )))

   (= creature!stm (firstn creature!stmsize creature!stm))

   nil)

Update 9 may 2008:
I made a small change to the add-observation code to allow different craas to have a different short and/or longterm memory array size, and associate a different number of short-term memory with a longterm memory, as I've no idea yet what are good and functional sizes.

One of the major things that is still lacking from this memory is the issue of saturation / filtering uninteresting information. If there is always grass around you, you probably don't associate it with something, or let it fill your short-term memory. Two solutions come to mind: a module that 'filters' your observations in some way (perhaps by distincting between expected / unexpected, or by flagging things as 'not interesting'). A second possibility is that you can lump similar observations so that they don't take as much space in your short-term memory (1, 2, many trees). Moving from one place in the forest to another would just add a single 'many trees' observation to your shortterm memory, rather than filling your short-term memory with 'tree','tree','tree','tree','tree', and missing the 'bear'.
~

.Plan

Sun, 20 Jan 2008 11:04:00 +0100

Let's build something intelligent.

The goal is to create a rich virtual world in which some artificial life critters live. The critters are designed to be as close to a tabula rasa as I can manage to make them: the main difference between critters will be inherited physical characteristics (size, speed, quality of sight, smell or hearing) and their inherited preferential responses (attack, eat, move away, move towards, hide), which develops over time (ie, youngsters might prefer to hide, whereas adults might move away).Current status:

Have:

world with objects
animal that can memorize things (see Memory)

Need:

method for the animal to turn experiences and their associations into action.
genetic algorithm to improve the animals