LINUX & AI/ALIFE
MINI-HOWTO
Version 2.0
This document is maintained by John A. Eikenberry
The master page for this document is
http://www.ai.uga.edu/~jae/ai.html
Last modified: Sat Sep 27 17:49:35 EDT 1997
_________________________________________________________________
Table of Contents
* What's New
* Introduction
+ Purpose
+ Finding the Software
+ Updates and Comments
* Programming Languages
* Traditional Artificial Intelligence
+ AI class/code libraries
+ AI software kits, applications, etc.
* Connectionism (neural nets)
+ Connectionist Class/Code Libraries
+ Connectionist Applications
* Evolutionary Computing (EC) (genetic algorithms/programming)
+ EC Class/Code Libraries
+ EC Applications
* Artificial Life
+ Alife class/code libraries
+ Alife software kits, applications, etc.
* Autonomous Agents and Bots
* AI & Alife related newsgroups
* AI & Alife resource links
_________________________________________________________________
What's New
(9.26.97) The web page reformat is done! :) The reformat was to break
up the master page into a number of frames. The "All-in-0ne" format
will still be maintained (the framed version is generated from it via
a Python script). If you are reading this somew here other than the
master page, please take a look and let me know what you think. Now I
can get back to work on my thesis...
(8.4.97) Found a few bad links and fixed them. Added a new link the
"Scientific Applications for Linux" AI page (very nice). Added some
more stuff (not listed as I will have a new "what's new" section when
I get the reformat done and will list them there) . This will be my
lase update until I get the new format done. I've been a bit busy and
have not gotten it done, but I'm determined to finish it soon.
(5.18.97)I've done a bit of cleaning in the links section. I've also
added a genetic programming library (GP kernel), the ADATE system, the
Sugal (GA) system, Geco (GA), Grammer Work Bench (NLP), Screamer (lisp
library), SNePS, Ara, JATlite, Fuf and SURGE, and finally TIN (alife).
I've also begun a reorganization of this page. This will end up with
two versions of this page. One, like this one, containing the whole
howto, the second will be broken up into parts to allow for
troublesome connections.
(5.8.97)I've updated some dead or outdated links. I've collected a ton
of material to add over the last couple months, but have been
incredibly busy. I'm going to try to find the time to update this page
soon.
(3.4.97)I removed Scsh and put it on my linux page. The more I thought
about it, the less Scsh seemed an AI application. I also added Soar, a
general coginitive architecture development system. It looks pretty
cool and should work on Linux (any info to the contrary would be
appreciated, I don't have time right now t o mess with it). Last but
not least, I've added a couple more Scheme implementations to the list
(can you tell I really like scheme).
Purpose
The Linux OS has evolved from its origins in hackerdom to a full blown
UNIX, capable of rivaling any commercial UNIX. It now provides an
inexpensive base to build a great workstation. It has shed its
hardware dependencies, having been ported to DEC Alphas, Sparcs, mk86
(PowerPC/Amiga/etc.), with others on the way. This potential speed
boost along with its networking support will make it great for
workstation clusters. As a workstation it allows for all sorts of
research and development, including artificial intelligence and
artificial life.
The purpose of this Mini-Howto is to provide a source to find out
about various software packages, code libraries, and anything else
that will help someone get started working with (and find resources
for) artificial intelligence and artificial life. All done with Linux
specifically in mind.
Where to find this software
All this software should be available via the net (ftp || http). The
links to where to find it will be provided in the description of each
package. There will also be plenty of software not covered on these
pages (which is usually platform independent) located on one of the
locations listed in the resource links section.
Updates and comments
If you find any mistakes, know of updates to one of the items below,
or have problems compiling and of the applications, please mail me at:
jae@ai.uga.edu and I'll see what I can do.
If you know of any AI/Alife applications, class libraries, etc.
_Please_ email me about them. Include your name, ftp and/or http sites
where they can be found, plus a brief overview/commentary on the
software (this info would make things a lot easier on me... but don't
feel obligated ;).
I know that keeping this list up to date and expanding it will take
quite a bit of work. So please be patient (I do have other projects).
I hope you will find this document helpful.
_________________________________________________________________
Programming languages
While any programming language can be used for artificial
intelligence/life research, these are programming languages which are
used extensively for, if not specifically made for, artificial
intelligence programming.
G�del [NEW]
Web page: www.cs.bris.ac.uk/~bowers/goedel.html
G�del is a declarative, general-purpose programming language in
the family of logic programming languages. It is a strongly
typed language, the type system being based on many-sorted
logic with parametric polymorphism. It has a module system.
G�del supports infinite precision integers, infinite precision
rationals, and also floating-point numbers. It can solve
constraints over finite domains of integers and also linear
rational constraints. It supports processing of finite sets. It
also has a flexible computation rule and a pruning operator
which generalizes the commit of the concurrent logic
programming languages. Considerable emphasis is placed on
G�del's meta- logical facilities which provide significant
support for meta-programs that do analysis, transformation,
compilation, verification, debugging, and so on.
LIFE [NEW]
Web page: www.isg.sfu.ca/life
LIFE (Logic, Inheritance, Functions, and Equations) is an
experimental programming language proposing to integrate three
orthogonal programming paradigms proven useful for symbolic
computation. From the programmer's standpoint, it may be
perceived as a language taking after logic programming,
functional programming, and object-oriented programming. From a
formal perspective, it may be seen as an instance (or rather, a
composition of three instances) of a Constraint Logic
Programming scheme due to Hoehfeld and Smolka refining that of
Jaffar and Lassez.
CLisp (Lisp)
FTP site: sunsite.unc.edu/pub/Linux/devel/lang/lisp/
CLISP is a Common Lisp implementation by Bruno Haible and
Michael Stoll. It mostly supports the Lisp described by 'Common
LISP: The Language (2nd edition)' and the ANSI Common Lisp
standard. CLISP includes an interpreter, a byte-compiler, a
large subset of CLOS (Object-Oriented Lisp) , a foreign
language interface and, for some machines, a screen editor.
The user interface language (English, German, French) is chosen
at run time. Major packages that run in CLISP include CLX &
Garnet. CLISP needs only 2 MB of memory.
CMU Common Lisp [NEW]
Web page: www.mv.com/users/pw/lisp/index.html
FTP site: sunsite.unc.edu/pub/Linux/devel/lang/lisp/
CMU Common Lisp is a public domain "industrial strength" Common
Lisp programming environment. Many of the X3j13 changes have
been incorporated into CMU CL. Wherever possible, this has been
done so as to transparently allow the use of either CLtL1 or
proposed ANSI CL. Probably the new features most interesting to
users are SETF functions, LOOP and the WITH-COMPILATION-UNIT
macro.
GCL (Lisp)
FTP site: sunsite.unc.edu/pub/Linux/devel/lang/lisp/
GNU Common Lisp (GCL) has a compiler and interpreter for Common
Lisp. It used to be known as Kyoto Common Lisp. It is very
portable and extremely efficient on a wide class of
applications. It compares favorably in performance with
commercial Lisps on several large theorem-prover and symbolic
algebra systems. It supports the CLtL1 specification but is
moving towards the proposed ANSI definition. GCL compiles to C
and then uses the native optimizing C compilers (e.g., GCC). A
function with a fixed number of args and one value turns into a
C function of the same number of args, returning one value, so
GCL is maximally efficient on such calls. It has a conservative
garbage collector which allows great freedom for the C compiler
to put Lisp values in arbitrary registers.
It has a source level Lisp debugger for interpreted code, with
display of source code in an Emacs window. Its profiling tools
(based on the C profiling tools) count function calls and the
time spent in each function.
Mercury [NEW]
Web page: www.cs.mu.oz.au/research/mercury/
Mercury is a new, purely declarative logic programming
language. Like Prolog and other existing logic programming
languages, it is a very high-level language that allows
programmers to concentrate on the problem rather than the
low-level details such as memory management. Unlike Prolog,
which is oriented towards exploratory programming, Mercury is
designed for the construction of large, reliable, efficient
software systems by teams of programmers. As a consequence,
programming in Mercury has a different flavor than programming
in Prolog.
DFKI OZ
Web page: www.ps.uni-sb.de/oz/
FTP site: ps-ftp.dfki.uni-sb.de/pub/oz2/
Oz is a high-level programming language designed for concurrent
symbolic computation. It is based on a new computation model
providing a uniform and simple foundation for several
programming paradigms, including higher-order functional,
constraint logic, and concurrent object-oriented programming.
Oz is designed as a successor to languages such as Lisp, Prolog
and Smalltalk, which fail to support applications that require
concurrency, reactivity, and real-time control.
DFKI Oz is an interactive implementation of Oz featuring a
programming interface based on GNU Emacs, a concurrent browser,
an object-oriented interface to Tcl/Tk, powerful
interoperability features (sockets, C, C++), an incremental
compiler, a garbage collector, and support for stand-alone
applications. Performance is competitive with commercial Prolog
and Lisp systems.
BinProlog [NEW]
Web site(documentation):
clement.info.umoncton.ca/BinProlog/UNCOMPRESSED/doc/html/art.h
tml
FTP site(source): clement.info.umoncton.ca/BinProlog
FTP site(binary):
clement.info.umoncton.ca/BinProlog/UNCOMPRESSED/bin
BinProlog is a fast and compact Prolog compiler, based on the
transformation of Prolog to binary clauses. The compilation
technique is similar to the Continuation Passing Style
transformation used in some ML implementations. BinProlog 5.00
is also probably the first Prolog system featuring dynamic
recompilation of asserted predicates (a technique similar to
the one used in some object oriented languages like SELF 4.0),
and a very efficient segment preserving copying heap garbage
collector.
Although it (used to) incorporate some last minute research
experiments, which might look adventurous at the first sight,
BinProlog is a fairly robust and complete Prolog implementation
featuring both C-emulated execution and generation of
stand-alone applications by compilation to C.
SWI Prolog
Web page: swi.psy.uva.nl/projects/xpce/SWI-Prolog.html
FTP site: swi.psy.uva.nl/pub/SWI-Prolog/
SWI is a free version of prolog in the Edinburgh Prolog family
(thus making it very similar to Quintus and many other
versions). With: a large library of built in predicates, a
module system, garbage collection, a two-way interface with the
C language, plus many other features. It is meant as a
educational language, so it's compiled code isn't the fastest.
Although it similarity to Quintus allows for easy porting.
XPCE is freely available in binary form for the Linux version
of SWI-prolog. XPCE is an object oriented X-windows GUI
development package/environment.
BIGLOO Scheme
Web site: cuiwww.unige.ch/~serrano/bigloo.html
BIGLOO is a Scheme interpreter and compiler. It conforms to the
IEEE-Scheme standard (IEEE P1178) with some extensions, such as
regular expression parsing (RGC), a lexical analyzer generator,
a full foreign function interface, and a pattern matching
compiler. Bigloo can also compile modules written in Caml (an
ML dialect), letting you mix Scheme, ML, and C. Object-oriented
programming is provided by Meroon v3. The main goal of Bigloo
is to deliver small and fast stand alone applications. Bigloo
produces ANSI C and hence should be easy to port.
ELK Scheme
Web site: www.informatik.uni-bremen.de/~net/elk
US FTP site: ftp.x.org/contrib/devel_tools/
EU FTP site: ftp.tzi.uni-bremen.de/tzi/dmn/elk/
Elk (Extension Language Kit) has been designed specifically as
an embeddable, reusable extension language subsystem for
applications written in C or C++. Elk is also useful as a
stand-alone Scheme implementation, in particular as a platform
for rapid prototyping of X11-based Scheme programs. Elk was
first published in 1989; the current version is Elk 3.0. The
Elk distribution includes a Scheme interpreter (embeddable and
stand-alone versions), several dynamically loadable extensions,
run-time support (including a top-level implemented in Scheme
and a debugger), and 230+ pages of documentation (troff and
Postscript format).
Major features of Elk are incremental, dynamic loading of
compiled extensions (supported on many platforms); freezing of
the interpreter or application into a new executable file; a
C/C++ programmer's interface for language interoperability;
Scheme bindings for X11 Xlib, Xt, Athena and Motif Widgets; a
UNIX interface (not restricted to POSIX); bitstrings, records,
and regular expressions; a stop-and-copy and an incremental,
generational garbage collector.
Gambit-C Scheme
Web site: www.iro.umontreal.ca/~gambit/
FTP site: ftp.iro.umontreal.ca/pub/parallele/gambit
In this variant of Gambit, the compiler generates highly
portable C code that is reasonably efficient. The primary goals
of Gambit-C are portability and correctness (in particular it
correctly implements tail-recursion across modules and uses a
precise garbage-collector). Gambit-C runs on a wide range of
Unix workstations, on Macintosh, and DOS/Windows. It also
supports these features: dynamic-loading of compiled files,
C-interface (FFI), and a memory management system that expands
and contracts the heap based on the program's needs.
Kali Scheme [NEW]
Web site: www.neci.nj.nec.com/PLS/Kali.html
Kali Scheme is a distributed implementation of Scheme that
permits efficient transmission of higher-order objects such as
closures and continuations. The integration of distributed
communication facilities within a higher-order programming
language engenders a number of new abstractions and paradigms
for distributed computing. Among these are user-specified
load-balancing and migration policies for threads,
incrementally-linked distributed computations, agents, and
parameterized client-server applications. Kali Scheme supports
concurrency and communication using first-class procedures and
continuations. It integrates procedures and continuations into
a message-based distributed framework that allows any Scheme
object (including code vectors) to be sent and received in a
message.
MIT Scheme
Web site: www-swiss.ai.mit.edu/scheme-home.html
FTP site: swiss-ftp.ai.mit.edu:/archive/scheme-7.4/
MIT Scheme includes Edwin (Scheme's Emacs-like editor) and Liar
(the Scheme compiler). Does not have a convenient foreign
function interface yet. FTP distribution includes MIT C-Scheme
Reference and User manuals, as well as the Revised^4 Report on
Scheme.
MzScheme
Web site: www.cs.rice.edu/CS/PLT/packages/mzscheme
FTP site: ftp.cs.rice.edu/public/languages/plt/mzscheme/
MzScheme is fully R4RS -compilant (including the full numerical
tower), and also provides:
+ Pre-emptive threads for all platforms
+ Generative structures (a.k.a. _record data-types_)
+ A system for exceptions, where all primitive errors raise a
specific exception
+ First-class compilation units for organizing program
components
+ A class-based object system reminiscent of C++
+ Built-in regular expression matching tools
+ Simple TCP communication support on all platforms
+ Portable file-system access and process control commands
RScheme [NEW]
Web site:www.rosette.com/~donovan/rs/rscheme.html
FTP site: ftp.rosette.com/pub/rscheme
RScheme is an object-oriented, extended version of the Scheme
dialect of Lisp. RScheme is freely redistributable, and offers
reasonable performance despite being extraordinarily portable.
RScheme can be compiled to C, and the C can then compiled with
a normal C compiler to generate machine code. By default,
however, RScheme compiles to bytecodes which are interpreted by
a (runtime) virtual machine. This ensures that compilation is
fast and keeps code size down. In general, we recommend using
the (default) bytecode code generation system, and only
compiling your time-critical code to machine code. This allows
a nice adjustment of space/time tradeoffs. (see web site for
details)
Scheme->C
FTP site: gatekeeper.dec.com:/pub/DEC/Scheme-to-C/
Scheme->C is an R4RS compliant Scheme system that is centered
around a compiler that compiles Scheme to C. Besides the base
language, the system includes "expansion passing style" macros,
a foreign function call capability, records, weak pointers, 3
X11 interfaces, call/cc, and a generational, conservative,
copying garbage collector. The result is a system that is
portable, efficient, and able to build applications that
contain a mix of compiled and interpreted Scheme, and compiled
code from C, C++ and other languages.
Scheme48
Web site: www-swiss.ai.mit.edu/~jar/s48.html (download from ftp
site)
FTP site: swiss-ftp.ai.mit.edu:/archive/s48/
Scheme 48 is a Scheme implementation based on a virtual machine
architecture. Scheme 48 is designed to be straightforward,
flexible, reliable, and fast. It should be easily portable to
32-bit byte-addressed machines that have POSIX and ANSI C
support. In addition to the usual Scheme built-in procedures
and a development environment, library software includes
support for hygienic macros (as described in the Revised^4
Scheme report), multitasking, records, exception handling, hash
tables, arrays, weak pointers, and FORMAT. Scheme 48 implements
and exploits an experimental module system loosely derived from
Standard ML and Scheme Xerox. The development environment
supports interactive changes to modules and interfaces.
SCM (Scheme)
FTP site: swiss-ftp.ai.mit.edu:/archive/scm/
SCM conforms to the Revised^4 Report on the Algorithmic
Language Scheme and the IEEE P1178 specification. Scm is
written in C. It uses the following utilities (all available at
the ftp site).
+ SLIB (Standard Scheme Library) is a portable Scheme library
which is intended to provide compatibility and utility
functions for all standard Scheme implementations, including
SCM, Chez, Elk, Gambit, MacScheme, MITScheme, scheme->C,
Scheme48, T3.1, and VSCM, and is available as the file
slib2a0.tar.gz. Written by Aubrey Jaffer.
+ JACAL is a symbolic math system written in Scheme, and is
available as the file jacal1a4.tar.gz.
+ SCMCONFIG contains additional files for the SCM distribution
to build SCM on Unix machines using GNU autoconf.
+ SLIB-PSD is a portable debugger for Scheme (requires emacs
editor).
+ TURTLSCM is a turtle graphics package which works with SCM on
MSDOS or X11 machines. Written by Mkinen Sami (sjm@cc.tut.fi)
and Jarkko Leppanen (jtl@cc.tut.fi), it is available as the
file turtlegr.tar.Z.
+ XSCM is an X Windows interface to Xlib and the Motif and
OpenLook toolkits for the SCM interpreter. It requires
scm4a10 or later. It should be available as xscm1.05.tar.Z.
Contact campbell@redsox.bsw.com for more information.
Shift [NEW]
Web site: www.path.berkeley.edu/shift/
Shift is a programming language for describing dynamic networks
of hybrid automata. Such systems consist of components which
can be created, interconnected and destroyed as the system
evolves. Components exhibit hybrid behavior, consisting of
continuous-time phases separated by discrete-event transitions.
Components may evolve independently, or they may interact
through their inputs, outputs and exported events. The
interaction network itself may evolve.
Traditional Artificial Intelligence
Traditional AI is based around the ideas of logic, rule systems,
linguistics, and the concept of rationality. At its roots are
programming languages such as Lisp and Prolog. Expert systems are the
largest successful example of this paradigm. An expert system consists
of a detailed knowledge base and a complex rule system to utilize it.
Such systems have been used for such things as medical diagnosis
support and credit checking systems.
AI class/code libraries
These are libraries of code or classes for use in programming within
the artificial intelligence field. They are not meant as stand alone
applications, but rather as tools for building your own applications.
AI Search
FTP site: ftp.icce.rug.nl/pub/peter/
Submitted by: Peter M. Bouthoorn
Basically, the library offers the programmer a set of search
algorithms that may be used to solve all kind of different
problems. The idea is that when developing problem solving
software the programmer should be able to concentrate on the
representation of the problem to be solved and should not need
to bother with the implementation of the search algorithm that
will be used to actually conduct the search. This idea has been
realized by the implementation of a set of search classes that
may be incorporated in other software through _C++_'s features
of derivation and inheritance. The following search algorithms
have been implemented:
- depth-first tree and graph search.
- breadth-first tree and graph search.
- uniform-cost tree and graph search.
- best-first search.
- bidirectional depth-first tree and graph search.
- bidirectional breadth-first tree and graph search.
- AND/OR depth tree search.
- AND/OR breadth tree search.
Peter plans to release a new version of the library soon, which
will also be featured in a book about C++ and AI to appear this
year.
Chess In Lisp (CIL) [NEW]
FTP site: chess.onenet.net/pub/chess/uploads/projects/
The CIL (Chess In Lisp) foundation is a Common Lisp
implementaion of all the core functions needed for development
of chess applications. The main purpose of the CIL project is
to get AI researchers interested in using Lisp to work in the
chess domain.
Screamer
Web site: www.cis.upenn.edu/~screamer-tools/home.html
Screamer is an extension of Common Lisp that adds support for
nondeterministic programming. Screamer consists of two levels.
The basic nondeterministic level adds support for backtracking
and undoable side effects. On top of this nondeterministic
substrate, Screamer provides a comprehensive constraint
programming language in which one can formulate and solve mixed
systems of numeric and symbolic constraints. Together, these
two levels augment Common Lisp with practically all of the
functionality of both Prolog and constraint logic programming
languages such as CHiP and CLP(R). Furthermore, Screamer is
fully integrated with Common Lisp. Screamer programs can
coexist and interoperate with other extensions to Common Lisp
such as CLOS, CLIM and Iterate.
AI software kits, applications, etc.
These are various applications, software kits, etc. meant for research
in the field of artificial intelligence. Their ease of use will vary,
as they were designed to meet some particular research interest more
than as an easy to use commercial package.
ASA - Adaptive Simulated Annealing
Web site: www.ingber.com/#ASA-CODE
FTP site: ftp.ingber.com/
ASA (Adaptive Simulated Annealing) is a powerful global
optimization C-code algorithm especially useful for nonlinear
and/or stochastic systems.
ASA is developed to statistically find the best global fit of a
nonlinear non-convex cost-function over a D-dimensional space.
This algorithm permits an annealing schedule for 'temperature'
T decreasing exponentially in annealing-time k, T = T_0 exp(-c
k^1/D). The introduction of re-annealing also permits
adaptation to changing sensitivities in the multi-dimensional
parameter-space. This annealing schedule is faster than fast
Cauchy annealing, where T = T_0/k, and much faster than
Boltzmann annealing, where T = T_0/ln k.
Babylon
FTP site: ftp.gmd.de/gmd/ai-research/Software/Babylon/
BABYLON is a modular, configurable, hybrid environment for
developing expert systems. Its features include objects, rules
with forward and backward chaining, logic (Prolog) and
constraints. BABYLON is implemented and embedded in Common
Lisp.
CLEARS
Web site: www.coli.uni-sb.de/~clears/
The CLEARS system is an interactive graphical environment for
computational semantics. The tool allows exploration and
comparison of different semantic formalisms, and their
interaction with syntax. This enables the user to get an idea
of the range of possibilities of semantic construction, and
also where there is real convergence between theories.
CLIPS
Web site: www.jsc.nasa.gov/~clips/CLIPS.html
FTP site:
cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/areas/exper
t/systems/clips
CLIPS is a productive development and delivery expert system
tool which provides a complete environment for the construction
of rule and/or object based expert systems.
CLIPS provides a cohesive tool for handling a wide variety of
knowledge with support for three different programming
paradigms: rule-based, object-oriented and procedural.
Rule-based programming allows knowledge to be represented as
heuristics, or "rules of thumb," which specify a set of actions
to be performed for a given situation. Object-oriented
programming allows complex systems to be modeled as modular
components (which can be easily reused to model other systems
or to create new components). The procedural programming
capabilities provided by CLIPS are similar to capabilities
found in languages such as C, Pascal, Ada, and LISP.
EMA-XPS - A Hybrid Graphic Expert System Shell
Web site: wmwap1.math.uni-wuppertal.de:80/EMA-XPS/
EMA-XPS is a hybrid graphic expert system shell based on the
ASCII-oriented shell Babylon 2.3 of the German National
Research Center for Computer Sciences (GMD). In addition to
Babylon's AI-power (object oriented data representation,
forward and backward chained rules - collectible into sets,
horn clauses, and constraint networks) a graphic interface
based on the X11 Window System and the OSF/Motif Widget Library
has been provided.
FOOL & FOX
FTP site: ntia.its.bldrdoc.gov/pub/fuzzy/prog/
FOOL stands for the Fuzzy Organizer OLdenburg. It is a result
from a project at the University of Oldenburg. FOOL is a
graphical user interface to develop fuzzy rulebases. FOOL will
help you to invent and maintain a database that specifies the
behavior of a fuzzy-controller or something like that.
FOX is a small but powerful fuzzy engine which reads this
database, reads some input values and calculates the new
control value.
FUF and SURGE
Web site: www.dfki.de/lt/registry/generation/fuf.html
FTP site: ftp.cs.columbia.edu/pub/fuf/
FUF is an extended implementation of the formalism of
functional unification grammars (FUGs) introduced by Martin Kay
specialized to the task of natural language generation. It adds
the following features to the base formalism:
+ Types and inheritance.
+ Extended control facilities (goal freezing, intelligent
backtracking).
+ Modular syntax.
These extensions allow the development of large grammars which can be
processed efficiently and can be maintained and understood more
easily. SURGE is a large syntactic realization grammar of
English written in FUF. SURGE is developed to serve as a black
box syntactic generation component in a larger generation
system that encapsulates a rich knowledge of English syntax.
SURGE can also be used as a platform for exploration of grammar
writing with a generation perspective.
The Grammar Workbench
Web site: www.cs.kun.nl/agfl/GWB.html
The Grammar Workbench, or GWB for short, is an environment for
the comfortable development of Affix Grammars in the
AGFL-formalism. Its purposes are:
+ to allow the user to input, inspect and modify a grammar;
+ to perform consistency checks on the grammar;
+ to compute grammar properties;
+ to generate example sentences;
+ to assist in performing grammar transformations.
GSM Suite [NEW]
Web site: www.slip.net/~andrewm/gsm/
The GSM Suite is a set of programs for using Finite State
Machines in a graphical fashion. The suite consists of programs
that edit, compile, and print state machines. Included in the
suite is an editor program, gsmedit, a compiler, gsm2cc, that
produces a C++ implementation of a state machine, a PostScript
generator, gsm2ps, and two other minor programs. GSM is
licensed under the GNU Public License and so is free for your
use under the terms of that license.
Illuminator [NEW]
Web site:
documents.cfar.umd.edu/resources/source/illuminator.html
Illuminator is a toolset for developing OCR and Image
Understanding applications. Illuminator has two major parts: a
library for representing, storing and retrieving OCR
information, heretofore called dafslib, and an X-Windows "DAFS"
file viewer, called illum. Illuminator and DAFS lib were
designed to supplant existing OCR formats and become a standard
in the industry. They particularly are extensible to handle
more than just English. The features of this release:
+ 5 magnification levels for images
+ flagged characters and words
+ unicode support -- American, British, French, German, Greek,
Italian, MICR, Norwegian, Russian, Spanish, Swedish,
keyboards
+ reads DAFS, TIFF's, PDA's (image only)
+ save to DAFS, ASCII/UTF or Unicode
+ Entity Viewer - shows properties, character choices, bounding
boxes image fragment for a selected entity, change type,
change content, hierarchy mode
Jess, the Java Expert System Shell [NEW]
Web site: herzberg.ca.sandia.gov/jess/
Jess is a clone of the popular CLIPS expert system shell
written entirely in Java. With Jess, you can conveniently give
your applets the ability to 'reason'. Jess is compatible with
all versions of Java starting with version 1.0.2. Jess
implements the following constructs from CLIPS: defrules,
deffunctions, defglobals, deffacts, and deftemplates.
learn [NEW]
FTP site: sunsite.unc.edu/pub/Linux/apps/cai/
Learn is a vocable learning program with memory model.
Otter: An Automated Deduction System
Web site: www.mcs.anl.gov/home/mccune/ar/otter
Our current automated deduction system Otter is designed to
prove theorems stated in first-order logic with equality.
Otter's inference rules are based on resolution and
paramodulation, and it includes facilities for term rewriting,
term orderings, Knuth-Bendix completion, weighting, and
strategies for directing and restricting searches for proofs.
Otter can also be used as a symbolic calculator and has an
embedded equational programming system.
RIPPER [NEW]
Web site: www.research.att.com/~wcohen/ripperd.html
Ripper is a system for fast effective rule induction. Given a
set of data, Ripper will learn a set of rules that will predict
the patterns in the data. Ripper is written in ASCI C and comes
with documentation and some sample problems.
SNePS
Web site: www.cs.buffalo.edu/pub/sneps/WWW/
FTP site: ftp.cs.buffalo.edu/pub/sneps/
The long-term goal of The SNePS Research Group is the design
and construction of a natural-language-using computerized
cognitive agent, and carrying out the research in artificial
intelligence, computational linguistics, and cognitive science
necessary for that endeavor. The three-part focus of the group
is on knowledge representation, reasoning, and natural-language
understanding and generation. The group is widely known for its
development of the SNePS knowledge representation/reasoning
system, and Cassie, its computerized cognitive agent.
Soar [NEW]
Web site: www.isi.edu/soar/soar.html
FTP site: cs.cmu.edu/afs/cs/project/soar/public/Soar6/
Soar has been developed to be a general cognitive architecture.
We intend ultimately to enable the Soar architecture to:
+ work on the full range of tasks expected of an intelligent
agent, from highly routine to extremely difficult, open-ended
problems
+ represent and use appropriate forms of knowledge, such as
procedural, declarative, episodic, and possibly iconic
+ employ the full range of problem solving methods
+ interact with the outside world and
+ learn about all aspects of the tasks and its performance on
them.
In other words, our intention is for Soar to support all the
capabilities required of a general intelligent agent.
TCM (Toolkit for Conceptual Modeling) [NEW]
Web site: www.cs.vu.nl/~tcm/
FTP site: ftp.cs.vu.nl/pub/tcm/
TCM (Toolkit for Conceptual Modeling) is our suite of graphical
editors. TCM contains graphical editors for Entity-Relationship
diagrams, Class-Relationship diagrams, Data and Event Flow
diagrams, State Transition diagrams, Jackson Process Structure
diagrams and System Network diagrams, Function Refinement trees
and various table editors, such as a Function-Entity table
editor and a Function Decomposition table editor. TCM is easy
to use and performs numerous consistency checks, some of them
immediately, some of them upon request.
WEKA [NEW]
Web site: lucy.cs.waikato.ac.nz/~ml/
WEKA (Waikato Environment for Knowledge Analysis) is an
state-of-the-art facility for applying machine learning
techniques to practical problems. It is a comprehensive
software "workbench" that allows people to analyse real-world
data. It integrates different machine learning tools within a
common framework and a uniform user interface. It is designed
to support a "simplicity-first" methodology, which allows users
to experiment interactively with simple machine learning tools
before looking for more complex solutions.
Connectionism
Connectionism is a technical term for a group of related techniques.
These techniques include areas such as Artificial Neural Networks,
Semantic Networks and a few other similar ideas. My present focus is
on neural networks (though I am looking for resources on the other
techniques). Neural networks are programs designed to simulate the
workings of the brain. They consist of a network of small
mathematical-based nodes, which work together to form patterns of
information. They have tremendous potential and currently seem to be
having a great deal of success with image processing and robot
control.
Connectionist class/code libraries
These are libraries of code or classes for use in programming within
the Connectionist field. They are not meant as stand alone
applications, but rather as tools for building your own applications.
S-ElimBel [NEW]
Web site: www.spaces.uci.edu/thiery/elimbel/
S-ElimBel is an algorithm that computes the belief in a
Bayesian network, implemented in MIT-Scheme. This algorithm has
the particularity of being rather easy to understand. Moreover,
one can apply it to any kind of Bayesian network - it being
singly connected or muliply connected. It is, however, less
powerful than the standard algorithm of belief propagation.
Indeed, the computation has to be reconducted entirely for each
new evidence added to the network. Also, one needs to run the
algorithm as many times as one has nodes for which the belief
is wanted.
Matrix Class [NEW]
FTP site: pink.cs.ucla.edu/pub/
A simple, fast, efficient C++ Matrix class designed for
scientists and engineers. The Matrix class is well suited for
applications with complex math algorithms. As an demonstration
of the Matrix class, it was used to implement the backward
error propagation algorithm for a multi-layer feed-forward
artificial neural network.
ANSI-C Neural Networks [NEW]
Web site: www.geocities.com/CapeCanaveral/1624/
This site contains ANSC-C source code for 8 types of neural
nets, including:
+ Adaline Network
+ Backpropagation
+ Hopfield Model
+ (BAM) Bidirectional Associative Memory
+ Boltzmann Machine
+ Counterpropagation
+ (SOM) Self-Organizing Map
+ (ART1) Adaptive Resonance Theory
They were designed to help turn the theory of a particular network
model into the design for a simulator implementation , and to
help with embeding an actual application into a particular
network model.
Software for Flexible Bayesian Modeling [NEW]
Web site: www.cs.utoronto.ca/~radford/fbm.software.html
This software implements flexible Bayesian models for
regression and classification applications that are based on
multilayer perceptron neural networks or on Gaussian processes.
The implementation uses Markov chain Monte Carlo methods.
Software modules that support Markov chain sampling are
included in the distribution, and may be useful in other
applications.
Various (C++) Neural Networks
Web site: www.mcs.com/~drt/svbp.html
Submitted by: Don Tveter
Example neural net codes from the book, The Basis of Artificial
Intelligence. These are simple example codes of these various
neural nets. They work well as a good starting point for simple
experimentation and for learning what the code is like behind
the simulators. The types of networks available on this site
are: (implemented in C++)
+ The Backprop Package
+ The Nearest Neighbor Algorithms
+ The Interactive Activation Algorithm
+ The Hopfield and Boltzman machine Algorithms
+ The Linear Pattern Classifier
+ ART I
+ Bi-Directional Associative Memory
+ The Feedforward Counter-Propagation Network
Connectionist software kits/applications
These are various applications, software kits, etc. meant for research
in the field of Connectionism. Their ease of use will vary, as they
were designed to meet some particular research interest more than as
an easy to use commercial package.
Aspirin/MIGRAINES (am6.tar.Z on ftp site) [NEW]
FTP site:
sunsite.unc.edu/pub/academic/computer-science/neural-networks/
programs/Aspirin/
The software that we are releasing now is for creating, and
evaluating, feed-forward networks such as those used with the
backpropagation learning algorithm. The software is aimed both
at the expert programmer/neural network researcher who may wish
to tailor significant portions of the system to his/her precise
needs, as well as at casual users who will wish to use the
system with an absolute minimum of effort.
Neureka ANS (nn/xnn) [NEW]
Web site: www.bgif.no/neureka/
FTP site: ftp.ii.uib.no/pub/neureka/linux/
nn is a high-level neural network specification language. The
current version is best suited for feed-forward nets, but
recurrent models can and have been implemented, e.g. Hopfield
nets, Jordan/Elman nets, etc. In nn, it is easy to change
network dynamics. The nn compiler can generate C code or
executable programs (so there must be a C compiler available),
with a powerful command line interface (but everything may also
be controlled via the graphical interface, xnn). It is possible
for the user to write C routines that can be called from inside
the nn specification, and to use the nn specification as a
function that is called from a C program. Please note that no
programming is necessary in order to use the network models
that come with the system (`netpack').
xnn is a graphical front end to networks generated by the nn
compiler, and to the compiler itself. The xnn graphical
interface is intuitive and easy to use for beginners, yet
powerful, with many possibilities for visualizing network data.
NOTE: You have to run the install program that comes with this
to get the license key installed. It gets put (by default) in
/usr/lib. If you (like myself) want to install the package
somewhere other than in the /usr directory structure (the
install program gives you this option) you will have to set up
some environmental variables (NNLIBDIR & NNINCLUDEDIR are
required). You can read about these (and a few other optional
variables) in appendix A of the documentation (pg 113).
PDP++
Web site: www.cnbc.cmu.edu/PDP++/
FTP site (US): cnbc.cmu.edu/pub/pdp++/
FTP site (Europe): unix.hensa.ac.uk/mirrors/pdp++/
As the field of Connectionist modeling has grown, so has the
need for a comprehensive simulation environment for the
development and testing of Connectionist models. Our goal in
developing PDP++ has been to integrate several powerful
software development and user interface tools into a general
purpose simulation environment that is both user friendly and
user extensible. The simulator is built in the C++ programming
language, and incorporates a state of the art script
interpreter with the full expressive power of C++. The
graphical user interface is built with the Interviews toolkit,
and allows full access to the data structures and processing
modules out of which the simulator is built. We have
constructed several useful graphical modules for easy
interaction with the structure and the contents of neural
networks, and we've made it possible to change and adapt many
things. At the programming level, we have set things up in such
a way as to make user extensions as painless as possible. The
programmer creates new C++ objects, which might be new kinds of
units or new kinds of processes; once compiled and linked into
the simulator, these new objects can then be accessed and used
like any other.
Simple Neural Net (in Python) [NEW]
Web site: starship.skyport.net/crew/amk/unmaintained/
Simple neural network code, which implements a class for
3-level networks (input, hidden, and output layers). The only
learning rule implemented is simple backpropagation. No
documentation (or even comments) at all, because this is simply
code that I use to experiment with. Includes modules containing
sample datasets from Carl G. Looney's NN book. Requires the
Numeric extensions.
SCNN [NEW]
Web site:
apx00.physik.uni-frankfurt.de/e_ag_rt/cnn/SCNN/homepage.html
SCNN is an universal simulating system for Cellular Neural
Networks (CNN). CNN are analog processing neural networks with
regular and local interconnections, governed by a set of
nonlinear ordinary differential equations. Due to their local
connectivity, CNN are realized as VLSI chips, which operates at
very high speed.
Semantic Networks in Python [NEW]
Web site: www-acs.ucsd.edu/~jstrout/python/ai/
The semnet.py module defines several simple classes for
building and using semantic networks. A semantic network is a
way of representing knowledge, and it enables the program to do
simple reasoning with very little effort on the part of the
programmer.
The following classes are defined:
+ _Entity_: This class represents a noun; it is something which
can be related to other things, and about which you can store
facts.
+ _Relation_: A Relation is a type of relationship which may
exist between two entities. One special relation, "IS_A", is
predefined because it has special meaning (a sort of logical
inheritance).
+ _Fact_: A Fact is an assertion that a relationship exists
between two entities.
With these three object types, you can very quickly define
knowledge about a set of objects, and query them for logical
conclusions.
SNNS
Web site:
www.informatik.uni-stuttgart.de/ipvr/bv/projekte/snns/snns.htm
l
FTP site: ftp.informatik.uni-stuttgart.de/pub/SNNS/
Stuttgart Neural Net Simulator (version 4.1). An awesome neural
net simulator. Better than any commercial simulator I've seen.
The simulator kernel is written in C (it's fast!). It supports
over 20 different network architectures, has 2D and 3D X-based
graphical representations, the 2D GUI has an integrated network
editor, and can generate a separate NN program in C.
SNNS is very powerful, though a bit difficult to learn at
first. To help with this it comes with example networks and
tutorials for many of the architectures.
ENZO, a supplementary system allows you to evolve your networks
with genetic algorithms.
The Readme.linux file that comes with this package must be old.
It's instructions for building the package are wrong. I've
edited it to reflect what I had to do to get the package to
compile. Please download SNNS.Readme.linux and use it instead
of the Readme.linux file that comes with the distribution.
SPRLIB/ANNLIB [NEW]
Web site: www.ph.tn.tudelft.nl/~sprlib/
SPRLIB (Statistical Pattern Recognition Library) was developed
to support the easy construction and simulation of pattern
classifiers. It consist of a library of functions (written in
C) that can be called from your own program. Most of the
well-known classifiers are present (k-nn, Fisher, Parzen,
....), as well as error estimation and dataset generation
routines.
ANNLIB (Artificial Neural Networks Library) is a neural network
simulation library based on the data architecture laid down by
SPRLIB. The library contains numerous functions for creating,
training and testing feed-forward networks. Training algorithms
include back-propagation, pseudo-Newton, Levenberg-Marquardt,
conjugate gradient descent, BFGS.... Furthermore, it is
possible - due to the datastructures' general applicability -
to build Kohonen maps and other more exotic network
architectures using the same data types.
Evolutionary Computing
Evolutionary computing is actually a broad term for a vast array of
programming techniques, including genetic algorithms, complex adaptive
systems, evolutionary programming, etc. The main thrust of all these
techniques is the idea of evolution. The idea that a program can be
written that will evolve toward a certain goal. This goal can be
anything from solving some engineering problem to winning a game.
EC class/code libraries
These are libraries of code or classes for use in programming within
the evolutionary computation field. They are not meant as stand alone
applications, but rather as tools for building your own applications.
FORTRAN GA [NEW]
Web site: www.staff.uiuc.edu/~carroll/ga.html
This program is a FORTRAN version of a genetic algorithm
driver. This code initializes a random sample of individuals
with different parameters to be optimized using the genetic
algorithm approach, i.e. evolution via survival of the fittest.
The selection scheme used is tournament selection with a
shuffling technique for choosing random pairs for mating. The
routine includes binary coding for the individuals, jump
mutation, creep mutation, and the option for single-point or
uniform crossover. Niching (sharing) and an option for the
number of children per pair of parents has been added. More
recently, an option for the use of a micro-GA has been added.
GAGS
Web site: kal-el.ugr.es/gags.html
FTP site: kal-el.ugr.es/GAGS/
Genetic Algorithm application generator and class library
written mainly in C++.
As a class library, and among other thing, GAGS includes:
+ A _chromosome hierarchy_ with variable length chromosomes.
_Genetic operators_: 2-point crossover, uniform crossover,
bit-flip mutation, transposition (gene interchange between 2
parts of the chromosome), and variable-length operators:
duplication, elimination, and random addition.
+ _Population level operators_ include steady state, roulette
wheel and tournament selection.
+ _Gnuplot wrapper_: turns gnuplot into a iostreams-like class.
+ Easy sample file loading and configuration file parsing.
As an application generator (written in PERL), you only need to supply
it with an ANSI-C or C++ fitness function, and it creates a C++
program that uses the above library to 90% capacity, compiles
it, and runs it, saving results and presenting fitness thru
gnuplot.
GAlib: Matthew's Genetic Algorithms Library
Web Site: lancet.mit.edu/ga/
FTP site: lancet.mit.edu/pub/ga/
Register GAlib at: http://lancet.mit.edu/ga/Register.html
GAlib contains a set of C++ genetic algorithm objects. The
library includes tools for using genetic algorithms to do
optimization in any C++ program using any representation and
genetic operators. The documentation includes an extensive
overview of how to implement a genetic algorithm as well as
examples illustrating customizations to the GAlib classes.
GALOPPS
Web site: isl.msu.edu/GA/software/galopps/index.html
FTP site: isl.cps.msu.edu/pub/GA/galopps/
GALOPPS is a flexible, generic GA, in 'C'. It was based upon
Goldberg's Simple Genetic Algorithm (SGA) architecture, in
order to make it easier for users to learn to use and extend.
GALOPPS extends the SGA capabilities several fold:
+ (optional) A new Graphical User Interface, based on TCL/TK,
for Unix users, allowing easy running of GALOPPS 3.2 (single
or multiple subpopulations) on one or more processors. GUI
writes/reads "standard" GALOPPS input and master files, and
displays graphical output (during or after run) of
user-selected variables.
+ 5 selection methods: roulette wheel, stochastic remainder
sampling, tournament selection, stochastic universal
sampling, linear-ranking-then-SUS.
+ Random or superuniform initialization of "ordinary"
(non-permutation) binary or non-binary chromosomes; random
initialization of permutation-based chromosomes; or
user-supplied initialization of arbitrary types of
chromosomes.
+ Binary or non-binary alphabetic fields on value-based
chromosomes, including different user-definable field sizes.
+ 3 crossovers for value-based representations: 1-pt, 2-pt, and
uniform, all of which operate at field boundaries if a
non-binary alphabet is used.
+ 4 crossovers for order-based reps: PMX, order-based, uniform
order-based, and cycle.
+ 4 mutations: fast bitwise, multiple-field, swap and random
sublist scramble.
+ Fitness scaling: linear scaling, Boltzmann scaling, sigma
truncation, window scaling, ranking.
+ _Plus_ a whole lot more....
GECO
FTP site: ftp://ftp.aic.nrl.navy.mil/pub/galist/src/
GECO (Genetic Evolution through Combination of Objects), an
extendible object-oriented tool-box for constructing genetic
algorithms (in Lisp). It provides a set of extensible classes
and methods designed for generality. Some simple examples are
also provided to illustrate the intended use.
gpjpp Genetic Programming in Java [NEW]
Web site: www.turbopower.com/~kimk/gpjpp.asp
gpjpp is a Java package I wrote for doing research in genetic
programming. It is a port of the gpc++ kernel written by Adam
Fraser and Thomas Weinbrenner. Included in the package are four
of Koza's standard examples: the artificial ant, the hopping
lawnmower, symbolic regression, and the boolean multiplexer.
Here is a partial list of its features:
+ graphic output of expression trees
+ efficient diversity checking
+ Koza's greedy over-selection option for large populations
+ extensible GPRun class that encapsulates most details of a
genetic programming test
+ more robust and efficient streaming code, with automatic
checkpoint and restart built into the GPRun class
+ an explicit complexity limit that can be set on each GP
+ additional configuration variables to allow more testing
without recompilation
+ support for automatically defined functions (ADFs)
+ tournament and fitness proportionate selection
+ demetic grouping
+ optional steady state population
+ subtree crossover
+ swap and shrink mutation
GP Kernel
Web site: www.emk.e-technik.th-darmstadt.de/~thomasw/gp.html
The GP kernel is a C++ class library that can be used to apply
genetic programming techniques to all kinds of problems. The
library defines a class hierarchy. An integral component is the
ability to produce automatically defined functions as found in
Koza's "Genetic Programming II".Technical documentation
(postscript format) is included. There is also a short
introduction into genetic programming.
Functionality includes; Automatically defined functions (ADFs),
tournament and fitness proportionate selection, demetic
grouping, optional steady state genetic programming kernel,
subtree crossover, swap and shrink mutation, a way of changing
every parameter of the system without recompilation, capacity
for multiple populations, loading and saving of populations and
genetic programs, standard random number generator, internal
parameter checks.
lil-gp
Web site: isl.msu.edu/GA/software/lil-gp/index.html
FTP site: isl.cps.msu.edu/pub/GA/lilgp/
lil-gp is a generic 'C' genetic programming tool. It was
written with a number of goals in mind: speed, ease of use and
support for a number of options including:
+ Generic 'C' program that runs on UNIX workstations
+ Support for multiple population experiments, using arbitrary
and user settable topologies for exchange, for a single
processor (i.e., you can do multiple population gp
experiments on your PC).
+ lil-gp manipulates trees of function pointers which are
allocated in single, large memory blocks for speed and to
avoid swapping.
PGAPack Parallel Genetic Algorithm Library [NEW]
Web site: www.mcs.anl.gov/home/levine/PGAPACK/index.html
FTP site: ftp.mcs.anl.gov/pub/pgapack/
PGAPack is a general-purpose, data-structure-neutral, parallel
genetic algorithm library. It is intended to provide most
capabilities desired in a genetic algorithm library, in an
integrated, seamless, and portable manner. Key features are in
PGAPack V1.0 include:
+ Callable from Fortran or C.
+ Runs on uniprocessors, parallel computers, and workstation
networks.
+ Binary-, integer-, real-, and character-valued native data
types.
+ Full extensibility to support custom operators and new data
types.
+ Easy-to-use interface for novice and application users.
+ Multiple levels of access for expert users.
+ Parameterized population replacement.
+ Multiple crossover, mutation, and selection operators.
+ Easy integration of hill-climbing heuristics.
+ Extensive debugging facilities.
+ Large set of example problems.
+ Detailed users guide.
Sugal
Web site: www.trajan-software.demon.co.uk/sugal.htm
Sugal [soo-gall] is the SUnderland Genetic ALgorithm system.
The aim of Sugal is to support research and implementation in
Genetic Algorithms on a common software platform. As such,
Sugal supports a large number of variants of Genetic
Algorithms, and has extensive features to support customization
and extension.
EC software kits/applications
These are various applications, software kits, etc. meant for research
in the field of evolutionary computing. Their ease of use will vary,
as they were designed to meet some particular research interest more
than as an easy to use commercial package.
ADATE(Automatic Design of Algorithms Through Evolution)
Web site: www-ia.hiof.no/~rolando/adate_intro.html
ADATE is a system for automatic programming i.e., inductive
inference of algorithms, which may be the best way to develop
artificial and general intelligence.
The ADATE system can automatically generate non-trivial and
novel algorithms. Algorithms are generated through large scale
combinatorial search that employs sophisticated program
transformations and heuristics. The ADATE system is
particularly good at synthesizing symbolic, functional programs
and has several unique qualities.
esep & xesep [NEW]
Web site(esep): www.iit.edu/~linjinl/esep.html Web site(xesep):
www.iit.edu/~linjinl/xesep.html
This is a new scheduler, called Evolution Scheduler, based on
Genetic Algorithms and Evolutionary Programming. It lives with
original Linux priority scheduler.This means you don't have to
reboot to change the scheduling policy. You may simply use the
manager program esep to switch between them at any time, and
esep itself is an all-in-one for scheduling status, commands,
and administration. We didn't intend to remove the original
priority scheduler; instead, at least, esep provides you with
another choice to use a more intelligent scheduler, which
carries out natural competition in an easy and effective way.
Xesep is a graphical user interface to the esep (Evolution
Scheduling and Evolving Processes). It's intended to show users
how to start, play, and feel the Evolution Scheduling and
Evolving Processes, including sub-programs to display system
status, evolving process status, queue status, and evolution
scheduling status periodically in as small as one mini-second.
GPsys [NEW]
Web site: www.cs.ucl.ac.uk/staff/A.Qureshi/gpsys.html
GPsys (pronounced gipsys) is a Java (requires Java 1.1 or
later) based Genetic Programming system developed by Adil
Qureshi. The software includes documentation, source and
executables.
Feature Summary:
+ Steady State engine
+ ADF support
+ Strongly Typed
o supports generic functions and terminals
o has many built-in primitives
o includes indexed memory
+ Save/Load feature
o can save/load current generation to/from a file
o data stored in GZIP compression format to minimise disk
requirements
o uses serialisable objects for efficiency
+ Fully Documented
+ Example Problems
o Lawnmower (including GUI viewer)
o Symbolic Regression
+ Totally Parameterised
+ Fully Object Oriented and Extensible
+ High Performance
+ Memory Efficient
Alife
Alife takes yet another approach to exploring the mysteries of
intelligence. It has many aspects similar to EC and Connectionism, but
takes these ideas and gives them a meta-level twist. Alife emphasizes
the development of intelligence through emergent behavior of complex
adaptive systems. Alife stresses the social or group based aspects of
intelligence. It seeks to understand life and survival. By studying
the behaviors of groups of 'beings' Alife seeks to discover the way
intelligence or higher order activity emerges from seemingly simple
individuals. Cellular Automata and Conway's Game of Life are probably
the most commonly known applications of this field.
Alife class/code libraries
These are libraries of code or classes for use in programming within
the artificial life field. They are not meant as stand alone
applications, but rather as tools for building your own applications.
John von Neumann Universal Constructor
Web site: alife.santafe.edu/alife/software/jvn.html
FTP site: alife.santafe.edu/pub/SOFTWARE/jvn/
The universal constructor of John von Neumann is an extension
of the logical concept of universal computing machine. In the
cellular environment proposed by von Neumann both computing and
constructive universality can be achieved. Von Neumann proved
that in his cellular lattice both a Turing machine and a
machine capable of producing any other cell assembly, when fed
with a suitable program, can be embedded. He called the latter
machine a "universal constructor" and showed that, when
provided with a program containing its own description, this is
capable of self-reproducing.
Swarm
Web site: www.santafe.edu/projects/swarm
FTP site: ftp.santafe.edu/pub/swarm
The swarm Alife simulation kit. Swarm is a simulation
environment which facilitates development and experimentation
with simulations involving a large number of agents behaving
and interacting within a dynamic environment. It consists of a
collection of classes and libraries written in Objective-C and
allows great flexibility in creating simulations and analyzing
their results. It comes with three demos and good
documentation.
Swarm 1.0 is out. It requires _libtclobjc_ and _BLT 2.1_ (both
available at the swarm site).
Alife software kits, applications, etc.
These are various applications, software kits, etc. meant for research
in the field of artificial life. Their ease of use will vary, as they
were designed to meet some particular research interest more than as
an easy to use commercial package.
BugsX
FTP site:
ftp.Germany.EU.net/pub/research/softcomp/Alife/packages/bugsx/
Display and evolve biomorphs. It is a program which draws the
biomorphs based on parametric plots of Fourier sine and cosine
series and let's you play with them using the genetic
algorithm.
The Cellular Automata Simulation System [NEW]
Web site: www.cs.runet.edu/~dana/ca/cellular.html
The system consists of a compiler for the Cellang cellular
automata programming language, along with the corresponding
documentation, viewer, and various tools. Cellang has been
undergoing refinement for the last several years (1991-1995),
with corresponding upgrades to the compiler. Postscript
versions of the tutorial and language reference manual are
available for those wanting more detailed information. The most
important distinguishing features of Cellang, include support
for:
+ any number of dimensions;
+ compile time specification of each dimensions size; cell
neighborhoods of any size (though bounded at compile time)
and shape;
+ positional and time dependent neighborhoods;
+ associating multiple values (fields), including arrays, with
each cell;
+ associating a potentially unbounded number of mobile agents [
Agents are mobile entities based on a mechanism of the same
name in the Creatures system, developed by Ian Stephenson
(ian@ohm.york.ac.uk).] with each cell; and
+ local interactions only, since it is impossible to construct
automata that contain any global control or references to
global variables.
dblife & dblifelib
FTP site: ftp.cc.gatech.edu/ac121/linux/games/amusements/life/
_dblife:_ Sources for a fancy Game of Life program for X11 (and
curses). It is not meant to be incredibly fast (use xlife for
that:-). But it IS meant to allow the easy editing and viewing
of Life objects and has some powerful features. The related
dblifelib package is a library of Life objects to use with the
program.
_dblifelib:_ This is a library of interesting Life objects,
including oscillators, spaceships, puffers, and other weird
things. The related dblife package contains a Life program
which can read the objects in the Library.
Drone
Web site: pscs.physics.lsa.umich.edu/Software/Drone/
Drone is a tool for automatically running batch jobs of a
simulation program. It allows sweeps over arbitrary sets of
parameters, as well as multiple runs for each parameter set,
with a separate random seed for each run. The runs may be
executed either on a single computer or over the Internet on a
set of remote hosts. Drone is written in Expect (an extension
to the Tcl scripting language) and runs under Unix. It was
originally designed for use with the Swarm agent-based
simulation framework, but Drone can be used with any simulation
program that reads parameters from the command line or from an
input file.
EcoLab [NEW]
Web site: parallel.acsu.unsw.edu.au/rks/ecolab.html
EcoLab is a system that implements an abstract ecology model.
It is written as a set of Tcl/Tk commands so that the model
parameters can easily be changed on the fly by means of editing
a script. The model itself is written in C++.
LEE
Web site: www-cse.ucsd.edu/users/fil/lee/lee.html
FTP site: cs.ucsd.edu/pub/LEE/
LEE (Latent Energy Environments) is both an Alife model and a
software tool to be used for simulations within the framework
of that model. We hope that LEE will help understand a broad
range of issues in theoretical, behavioral, and evolutionary
biology. The LEE tool described here consists of approximately
7,000 lines of C code and runs in both Unix and Macintosh
platforms.
Net-Life & ZooLife
Web site:www.geocities.com/SiliconValley/Heights/1051**
FTP site: ftp.coe.uga.edu/users/jae/alife/
*(netlife-2.0.tar.gz contains both Net-Life and ZooLife)
_Net-Life_ is a simulation of artificial-life, with neural
"brains" generated via slightly random techniques. Net-Life
uses artificial neural nets and evolutionary algorithms to
breed artificial organisms that are similar to single cell
organisms. Net-life uses asexual reproduction of its fittest
individuals with a chance of mutation after each round to
eventually evolve successful life-forms.
_ZooLife_ is a simulation of artificial-life. ZooLife uses
probabilistic methods and evolutionary algorithms to breed
artificial organisms that are similar to plant/animal zoo
organisms. ZooLife uses asexual reproduction with a chance of
mutation.
Primordial Soup [NEW]
Web site: alife.santafe.edu/alife/software/psoup.html
Primordial Soup is an artificial life program. Organisms in the
form of computer software loops live in a shared memory space
(the "soup") and self-reproduce. The organisms mutate and
evolve, behaving in accordance with the principles of Darwinian
evolution.
The program may be started with one or more organisms seeding
the soup. Alternatively, the system may be started "sterile",
with no organisms present. Spontaneous generation of
self-reproducing organisms has been observed after runs as
short as 15 minutes.
Tierra
Web site: www.hip.atr.co.jp/~ray/tierra/tierra.html
FTP site: alife.santafe.edu/pub/SOFTWARE/Tierra/
Alternate FTP site:
ftp.cc.gatech.edu/ac121/linux/science/biology/
Tierra's written in the C programming language. This source
code creates a virtual computer and its operating system, whose
architecture has been designed in such a way that the
executable machine codes are evolvable. This means that the
machine code can be mutated (by flipping bits at random) or
recombined (by swapping segments of code between algorithms),
and the resulting code remains functional enough of the time
for natural (or presumably artificial) selection to be able to
improve the code over time.
TIN
FTP site: ftp.coe.uga.edu/users/jae/alife/
This program simulates primitive life-forms, equipped with some
basic instincts and abilities, in a 2D environment consisting
of cells. By mutation new generations can prove their success,
and thus passing on "good family values".
The brain of a TIN can be seen as a collection of processes,
each representing drives or impulses to behave a certain way,
depending on the state/perception of the environment ( e.g.
presence of food, walls, neighbors, scent traces) These
behavior process currently are : eating, moving, mating,
relaxing, tracing others, gathering food and killing. The
process with the highest impulse value takes control, or in
other words: the tin will act according to its most urgent
need.
XLIFE
FTP site: ftp.cc.gatech.edu/ac121/linux/games/amusements/life/
This program will evolve patterns for John Horton Conway's game
of Life. It will also handle general cellular automata with the
orthogonal neighborhood and up to 8 states (it's possible to
recompile for more states, but very expensive in memory).
Transition rules and sample patterns are provided for the
8-state automaton of E. F. Codd, the Wireworld automaton, and a
whole class of `Prisoner's Dilemma' games.
Autonomous Agents
Also known as intelligent software agents or just agents, this area
of AI research deals with simple applications of small programs that
aid the user in his/her work. They can be mobile (able to stop their
execution on one machine and resume it on another) or static (live in
one machine). They are usually specific to the task (and therefore
fairly simple) and meant to help the user much as an assistant would.
The most popular (ie. widely known) use of this type of application to
date are the web robots that many of the indexing engines (eg.
webcrawler) use.
AgentK
FTP site: ftp.csd.abdn.ac.uk/pub/wdavies/agentk
This package synthesizes two well-known agent paradigms:
Agent-Oriented Programming, Shoham (1990), and the Knowledge
Query & Manipulation Language, Finin (1993). The initial
implementation of AOP, Agent-0, is a simple language for
specifying agent behaviour. KQML provides a standard language
for inter-agent communication. Our integration (which we have
called Agent-K) demonstrates that Agent-0 and KQML are highly
compatible. Agent-K provides the possibility of inter-operable
(or open) software agents, that can communicate via KQML and
which are programmed using the AOP approach.
Agent, the Perl5 Module
FTP site: ftp.hawk.igs.net/pub/users/jduncan/modules/Agent/
The Agent is a prototype for an Information Agent system. It is
both platform and language independent, as it stores contained
information in simple packed strings. It can be packed and
shipped across any network with any format, as it freezes
itself in its current state.
AGENT TCL
Web site: www.cs.dartmouth.edu/~agent/
FTP site: ftp.cs.dartmouth.edu/pub/agents/
A transportable agent is a program that can migrate from
machine to machine in a heterogeneous network. The program
chooses when and where to migrate. It can suspend its execution
at an arbitrary point, transport to another machine and resume
execution on the new machine. For example, an agent carrying a
mail message migrates first to a router and then to the
recipient's mailbox. The agent can perform arbitrarily complex
processing at each machine in order to ensure that the message
reaches the intended recipient.
Aglets Workbench [NEW]
Web site: www.trl.ibm.co.jp/aglets/
An aglet is a Java object that can move from one host on the
Internet to another. That is, an aglet that executes on one
host can suddenly halt execution, dispatch to a remote host,
and resume execution there. When the aglet moves, it takes
along its program code as well as its state (data). A built-in
security mechanism makes it safe for a computer to host
untrusted aglets. The Java Aglet API (J-AAPI) is a proposed
public standard for interfacing aglets and their environment.
J-AAPI contains methods for initializing an aglet, message
handling, and dispatching, retracting, deactivating/activating,
cloning, and disposing of the aglet. J-AAPI is simple,
flexible, and stable. Application developers can write
platform-independent aglets and expect them to run on any host
that supports J-AAPI.
Ara
Web site: www.uni-kl.de/AG-Nehmer/Ara/
Ara is a platform for the portable and secure execution of
mobile agents in heterogeneous networks. Mobile agents in this
sense are programs with the ability to change their host
machine during execution while preserving their internal state.
This enables them to handle interactions locally which
otherwise had to be performed remotely. Ara's specific aim in
comparison to similar platforms is to provide full mobile agent
functionality while retaining as much as possible of
established programming models and languages.
JATLite
Web site: java.stanford.edu/java_agent/html/
JATLite is providing a set of java packages which makes easy to
build multi-agent systems using Java. JATLite provides only
light-weight, small set of packages so that the developers can
handle all the packages with little efforts. For flexibility
JATLite provides four different layers from abstract to Router
implementation. A user can access any layer we are providing.
Each layer has a different set of assumptions. The user can
choose an appropriate layer according to the assumptions on the
layer and user's application. The introduction page contains
JATLite features and the set of assumptions for each layer.
Java(tm) Agent Template
Web site: cdr.stanford.edu/ABE/JavaAgent.html
The JAT provides a fully functional template, written entirely
in the Java language, for constructing software agents which
communicate peer-to-peer with a community of other agents
distributed over the Internet. Although portions of the code
which define each agent are portable, JAT agents are not
migratory but rather have a static existence on a single host.
This behavior is in contrast to many other "agent"
technologies. (However, using the Java RMI, JAT agents could
dynamically migrate to a foreign host via an agent resident on
that host). Currently, all agent messages use KQML as a
top-level protocol or message wrapper. The JAT includes
functionality for dynamically exchanging "Resources", which can
include Java classes (e.g. new languages and interpreters,
remote services, etc.), data files and information inlined into
the KQML messages.
Java-To-Go [NEW]
Web site: ptolemy.eecs.berkeley.edu/dgm/javatools/java-to-go/
Java-To-Go is an experimental infrastructure that assists in
the development and experimentation of mobile agents and
agent-based applications for itinerative computing (itinerative
computing: the set of applications that requires site-to-site
computations. The main emphasis here is on a easy-to-setup
environment that promotes quick experimentation on mobile
agents.
Kafka [NEW]
Web site: www.fujitsu.co.jp/hypertext/free/kafka/
Kafka is yet another agent library designed for constructing
multi-agent based distributed applications. Kafka is a
flexible, extendable, and easy-to-use java class library for
programmers who are familiar with distributed programming. It
is based on Java's RMI and has the following added features:
Runtime Reflection:
Agents can modify their behaviour (program codes) at
runtime. The behaviour of the agent is represented by an
abstract class Action. It is useful for remote
maintenance or installation services.
Remote Evaluation:
Agents can receive and evaluate program codes (classes)
with or without the serialized object. Remote evaluation
is a fundamental function of a mobile agent and is
thought to be a push model of service delivery.
Distributed Name Service:
Agents have any number of logical names that don't
contain the host name. These names can be managed by the
distributed directories.
Customizable security policy
a very flexible, customizable, 3-layered security model
is implemented in Kafka.
100% Java and RMI compatible:
Kafka is written completely in Java. Agent is a Java RMI
server object itself. So, agents can directly communicate
with other RMI objects.
Khepera Simulator
Web site: diwww.epfl.ch/lami/team/michel/khep-sim/
Khepera Simulator is a public domain software package written
by Olivier MICHEL during the preparation of his Ph.D. thesis,
at the Laboratoire I3S, URA 1376 of CNRS and University of
Nice-Sophia Antipolis, France. It allows to write your own
controller for the mobile robot Khepera using C or C++
languages, to test them in a simulated environment and features
a nice colorful X11 graphical interface. Moreover, if you own a
Khepera robot, it can drive the real robot using the same
control algorithm. It is mainly oriented toward to researchers
studying autonomous agents.
Mole [NEW]
Web site:
www.informatik.uni-stuttgart.de/ipvr/vs/projekte/mole.html
Mole is an agent system supporting mobile agents programmed in
Java. Mole's agents consist of a cluster of objects, which have
no references to the outside, and as a whole work on tasks
given by the user or another agent. They have the ability to
roam a network of "locations" autonomously. These "locations"
are an abstraction of real, existing nodes in the underlying
network. They can use location-specific resources by
communicating with dedicated agents representing these
services. Agents are able to use services provided by other
agents and to provide services as well.
Odyssey [NEW]
Web site: www.genmagic.com/agents/
Odyssey is General Magic's initial implementation of mobile
agents in 100% pure Java. The Odyssey class libraries enable
you to develop your own mobile agent applications. Use mobile
agents to access data, make decisions and notify users. Your
agent-enabled applications may also take full advantage of the
Java platform and use other third party libraries, for example,
to access remote CORBA objects or to access relational
databases using JDBC. To see how it's done, take a look at the
sample applications included as part of the Odyssey download.
Penguin!
FTP site:
www.perl.org/CPAN/modules/by-category/23_Miscellaneous_Modules
/Penguin/FSG/
Penguin is a Perl 5 module. It provides you with a set of
functions which allow you to:
+ send encrypted, digitally signed Perl code to a remote
machine to be executed.
+ receive code and, depending on who signed it, execute it in
an arbitrarily secure, limited compartment.
The combination of these functions enable direct Perl coding of
algorithms to handle safe internet commerce, mobile
information-gathering agents, "live content" web browser helper
apps, distributed load-balanced computation, remote software
update, distance machine administration, content-based
information propagation, Internet-wide shared-data
applications, network application builders, and so on.
SimRobot [NEW]
Web site: www.informatik.uni-bremen.de/~simrobot/
FTP site: ftp.uni-bremen.de/pub/ZKW/INFORM/simrobot/
SimRobot is a program for simulation of sensor based robots in
a 3D environment. It is written in C++, runs under UNIX and X11
and needs the graphics toolkit XView.
+ Simulation of robot kinematics
+ Hierarchically built scene definition via a simple definition
language
+ Various sensors built in: camera, facette eye, distance
measurement, light sensor, etc.
+ Objects defined as polyeders
+ Emitter abstractly defined; can be interpreted e.g. as light
or sound
+ Camera images computed according to the raytracing or
Z-buffer algorithms known from computer graphics
+ Specific sensor/motor software interface for communicating
with the simulation
+ Texture mapping onto the object surfaces: bitmaps in various
formats
+ Comprehensive visualization of the scene: wire frame w/o
hidden lines, sensor and actor values
+ Interactive as well as batch driven control of the agents and
operation in the environment
+ Collision detection
+ Extendability with user defined object types
+ Possible socket communication to e.g. the Khoros image
processing software
TclRobots
FTP site: ftp.neosoft.com/pub/tcl/sorted/games/tclrobots-2.0/
Redhat Patch:
ftp.coe.uga.edu/users/jae/ai/tclrobots-redhat.patch
RPMs: ftp://ftp.redhat.com/contrib/
TclRobots is a programming game, similar to 'Core War'. To play
TclRobots, you must write a Tcl program that controls a robot.
The robot's mission is to survive a battle with other robots.
Two, three, or four robots compete during a battle, each
running different programs (or possibly the same program in
different robots.) Each robot is equipped with a scanner,
cannon, drive mechanism. A single match continues until one
robot is left running. Robots may compete individually, or
combine in a team oriented battle. A tournament can be run with
any number of robot programs, each robot playing every other in
a round-robin fashion, one-on-one. A battle simulator is
available to help debug robot programs.
The TclRobots program provides a physical environment, imposing
certain game parameters to which all robots must adhere.
TclRobots also provides a view on a battle, and a controlling
user interface. TclRobots requirements: a wish interpreter
built from Tcl 7.4 and Tk 4.0.
The Tocoma Project [NEW]
Web site: www.cs.uit.no/DOS/Tacoma/index.html
An agent is a process that may migrate through a computer
network in order to satisfy requests made by clients. Agents
are an attractive way to describe network-wide computations.
The TACOMA project focuses on operating system support for
agents and how agents can be used to solve problems
traditionally addressed by operating systems. We have
implemented a series of prototype systems to support agents.
TACOMA Version 1.2 is based on UNIX and TCP. The system
supports agents written in C, Tcl/Tk, Perl, Python, and Scheme
(Elk). It is implemented in C. This TACOMA version has been in
public domain since April 1996.
We are currently focusing on heterogeneity, fault-tolerance,
security and management issues. Also, several TACOMA
applications are under construction. We implemented StormCast
4.0, a wide-area network weather monitoring system accessible
over the internet, using TACOMA and Java. We are now in the
process of evaluating this application, and plan to build a new
StormCast version to be completed by June 1997.
VWORLD
Web site: www.ai.uga.edu/students/jae/projects.html#vworld
Vworld is a simulated environment for research with autonomous
agents written in prolog. It is currently in something of an
beta stage. It works well with SWI-prolog, but should work with
Quitnus-prolog with only a few changes. It is being designed to
serve as an educational tool for class projects dealing with
prolog and autonomous agents. It comes with three demo worlds
or environments, along with sample agents for them.
There are two versions now. One written for SWI-prolog and one
written for LPA-prolog. Documentation is roughly done (with a
student/professor framework in mind), and a graphical interface
is planned.
AI & Alife related newsgroups
These newsgroups are not Linux specific. But they are good resources
for anyone working in artificial intelligence or artificial life. If
you can't access these newsgroups, many of their FAQs are available
at:
http://www.cis.ohio-state.edu/hypertext/faq/bngusenet/comp/ai/top.html
* comp.ai
* comp.ai.edu
* comp.ai.genetic
* comp.ai.neural-nets
* comp.ai.vision
* comp.ai.fuzzy
* comp.ai.games
* comp.ai.jair.announce
* comp.ai.jair.papers
* comp.ai.nat-lang
* comp.ai.nlang-know-rep
* comp.ai.philosophy
* comp.ai.shells
* comp.ai.alife
* comp.ai.doc-analysis.misc
* comp.ai.doc-analysis.ocr
* comp.lang.prolog
* comp.lang.lisp
* alt.irc.bots
AI & Alife resource links
These are a few of the many AI and Alife sites out there. These sites
are good places to start hunting for more information or for finding
software. I'll be adding more links to this list soon, as well as
organizing it better. These links are not Linux specific, but I wanted
to include them to provide a jump off point to the huge amount of info
related to these topics located on the web.
AI & Alife archives, software resources, etc.
* SAL.KachinaTech.COM/Z/3/-Scientific Applications for Linux's AI
page [NEW]
* alife.santafe.edu/~joke/zooland/-ZooLand Artificial Life Resources
* www.neuronet.ph.kcl.ac.uk/neuronet/software/software.html-NEuroNet
- ANN software
* www.cs.cmu.edu/Web/Groups/AI/html/repository.html-CMU Artificial
Intelligence Repository
* ftp.io.com/pub/genetic-programming/-John Koza's Genetic
Programming archive.
AI/Alife Research, Bibliographies, Books, etc.
* www.mcs.net/~jorn/html/ai.html-Outsider's Guide to AI [NEW]
*
www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/cl
m/clm.html-Common Lisp Book
* www.elwoodcorp.com/alu/table/contents.htm-The Association of Lisp
Users [NEW]
* www.cs.indiana.edu/scheme-repository/home.html-Scheme repository
* agents.www.media.mit.edu/groups/agents/-MIT Media Lab, Autonomous
Agents Group
* www.aic.nrl.navy.mil/-Navy Center for Applied Research in
Artificial Intelligence
* intranet.ca/~sshah/waste/waste.html-WASTE (AI Contest)
* www.cs.washington.edu/research/jair/home.html-Journal of
Artificial Intelligence Research
* www.cs.ucl.ac.uk/misc/ai/-University of London's AI Resource Page
* www.cris.com/~swoodcoc/ai.html -Artificial Intelligence in Games
* www.cs.umbc.edu/agents/agentnews/-AgentNews Webletter
* www.agent.org-Agent Society Home Page [NEW]
* www.botspot.com/main.html-The BotSpot (a software agent resource
page) [NEW]
* drogo.cselt.stet.it/fipa/-FIPA Foundation for Intelligent Physical
Agents [NEW]
* www.robotmag.com/-Robot Magazine [NEW]
* alife.santafe.edu/~joke/encore/-ENCORE-The Hitch-Hikers Guide to
Evolutionary Computation
* alife.santafe.edu-Santafe's Alife page
* www.krl.caltech.edu/~brown/alife/-Alife FAQ
* www.cogs.susx.ac.uk/users/ezequiel/alife-page/alife.html-ALife
Bibliography
* complex.csu.edu.au/complex/-Complex Systems Information Network
* www.geneticprogramming.com/-The Genetic Programming Notebook [NEW]
* gracco.irmkant.rm.cnr.it/luigi/lupa_algames.html-The Artificial
Life Games Homepage
* www.krl.caltech.edu/~charles/alife-game/-Project: Von Neumann
* gal4.ge.uiuc.edu/illigal.home.html-IlliGAL Home Page (GA's)
* isl.msu.edu/GA/-MSU GARAGe Home Page (GA's)
* www.aracnet.com/~wwir/NovaGenetica/-Nova Genetica (GA's)
_________________________________________________________________
This page created and maintained by
John Eikenberry
All Standard Disclaimers Apply