mirror of https://github.com/tLDP/LDP
6151 lines
252 KiB
Plaintext
6151 lines
252 KiB
Plaintext
<!doctype linuxdoc system>
|
||
|
||
<article>
|
||
|
||
<title>GNU/Linux AI & Alife HOWTO
|
||
<author>by <htmlurl url="mailto:jae@zhar.net" name="John Eikenberry">
|
||
<date>v3.1, 31 Mar 2013
|
||
|
||
<abstract>
|
||
This howto mainly contains information about, and links to,
|
||
various AI related software libraries, applications, etc.
|
||
that work on the GNU/Linux platform. All of it is (at least)
|
||
free for personal use.
|
||
|
||
The new master page for this document is <htmlurl url="http://zhar.net/howto/">
|
||
</abstract>
|
||
|
||
<toc>
|
||
|
||
<sect>Introduction
|
||
<label id="Introduction">
|
||
<p>
|
||
|
||
<sect1>Purpose
|
||
<p>
|
||
|
||
The GNU/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,
|
||
PowerPCs, and many others. 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 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, artificial life, etc. All done with
|
||
GNU/Linux specifically in mind.
|
||
|
||
<sect1>What's New
|
||
<p>
|
||
|
||
<itemize>
|
||
|
||
<item>v3.2 -
|
||
|
||
<p>New entries: <ref id="Simbrain">, <ref id="lens">.
|
||
|
||
<item>v3.1 -
|
||
|
||
<p>New entries: <ref id="SimpleAI">.
|
||
|
||
<p>Resurfaced MIA entry: <ref id="NuPIC">.
|
||
|
||
<p>Deleted the section on "Programming languages". I moved the couple of
|
||
agent-oriented domain specific languages, <ref id="2APL"> and <ref
|
||
id="APRIL">, into the sections relevant to the work. I removed the rest as
|
||
they were all just general purpose languages.
|
||
|
||
<p>Changed my Copyright/License to <htmlurl
|
||
url="http://creativecommons.org/publicdomain/zero/1.0/" name="CC0">. That
|
||
is no copyright, it is Public Domain. I no longer wish to take part in
|
||
copyright; <htmlurl url="http://questioncopyright.org/">
|
||
|
||
|
||
<item>v3.0 -
|
||
|
||
<p>New entries: <ref id="ORTS">, <ref id="FANN">, <ref id="OpenCV">,
|
||
<ref id="CBR Microprograms">, <ref id="ConceptNet">, <ref id="FreeHAL">,
|
||
<ref id="2APL">, <ref id="Alchemy">, <ref id="plop">, <ref id="evolver">,
|
||
<ref id="PyIE">, <ref id="Pyevolve">, <ref id="txevolver">,
|
||
<ref id="python-dlp">, <ref id="CompLearn">, <ref id="dbacl">,
|
||
<ref id="Maximum Entropy Toolkit">, <ref id="pebl">, <ref id="FLiP">,
|
||
<ref id="Carmen">, <ref id="Orca">, <ref id="ROS">, <ref id="YARP">,
|
||
<ref id="Neuroph">, <ref id="MLAP book samples">, <ref id="Elefant">,
|
||
<ref id="Evocosm">, <ref id="Critterding">, <ref id="MRPT">,
|
||
<ref id="PyBrain">, <ref id="peach">, <ref id="brain">, <ref id="FREVO">,
|
||
<ref id="Vowpal Wabbit">, <ref id="ERESYE">, <ref id="Recast">,
|
||
<ref id="EAP">, <ref id="GenePool">, <ref id="Milk">, <ref id="OpenCog">,
|
||
<ref id="Pattern">, <ref id="CognitiveFoundry">, <ref id="clasp">,
|
||
<ref id="timbl">, <ref id="MBT">, <ref id="scikits.learn">,
|
||
<ref id="NeuroLab">, <ref id="Biogenesis">, <ref id="brain-simulator">.
|
||
<ref id="Torch5">, <ref id="Encog">, <ref id="Nengo">,
|
||
<ref id="DEAP"> and <ref id="Emergent">.
|
||
|
||
<p>Changed the name of the "Traditional" section to
|
||
<ref id="Symbolic Systems (GOFAI)">. Added new section,
|
||
<ref id="Statistical & Machine Learning">.
|
||
|
||
<p>Seems someone has resuscitated <ref id="EMA-XPS">. Not very active, but
|
||
enough to pull out of the dead projects area and place back amounst the
|
||
living. I also fixed many links and moved quite a few dead projects to
|
||
<ref id="Missing & Dead">.
|
||
|
||
|
||
<item>v2.4 -
|
||
|
||
<p>New entries: <ref id="Eprover">, <ref id="Player">, <ref id="Logfun">,
|
||
<ref id="Livingstone2">, <ref id="Quackle">, <ref id="LingPipe">, <ref
|
||
id="GATE">, <ref id="Infon Battle Arena">, <ref id="CLARAty">, <ref
|
||
id="Reverend">, <ref id="Shogun">, <ref id="Nanopond">, <ref
|
||
id="Polyworld">, <ref id="Fluidiom">, <ref id="NEAT">, <ref
|
||
id="Framsticks">, <ref id="URBI">, <ref id="RobotFlow">, <ref id="Nero">,
|
||
<ref id="ffnet">, Alloy (removed), <ref id="Pyke">, <ref id="NuPIC">, <ref
|
||
id="Simbad">, <ref id="Robodeb">, <ref id="Loom">, <ref id="PowerLoom">,
|
||
<ref id="tinygp">, Curry (removed), <ref id="JGAP">, <ref id="PyCLIPS">,
|
||
and STELLA (removed).
|
||
|
||
<p>I chopped the Agents section into two sub-sections, one for <ref
|
||
id="Software Agents"> and one for <ref id="Robotics and Simulators">. I
|
||
play it a bit fast and loose in my deciding what goes into each category,
|
||
but it is an improvement.
|
||
|
||
<p>MIA found! <ref id="Cellular"> the cellular automata programming system.
|
||
Fixed many bad links and cleaned out missing projects.
|
||
|
||
<item>v2.3 -
|
||
|
||
<p>New entries: <ref id="Yampa">, <ref id="pygene">, Push (removed), <ref
|
||
id="ANNEvolve">, <ref id="dgpf">, <ref id="Golly">, <ref id="IBAL">, <ref
|
||
id="3APL">, <ref id="OSCAR">, and <ref id="RobocodeNG">.
|
||
|
||
<p>Updated information for some entries including <ref id="Yale">, <ref
|
||
id="Joone">, <ref id="Drone">, <ref id="Biome">, ECLiPSe (removed), <ref
|
||
id="Xtoys">, <ref id="GECO">, <ref id="Creatures Docking Station"> and
|
||
others.
|
||
|
||
<p>I also changed the MIA section to <ref id="Missing & Dead"> which now
|
||
groups into subsections entries with bad links that I can't find
|
||
replacements for and long dead projects.
|
||
|
||
<item>v2.2 -
|
||
|
||
<p>Fixed a some bad links and was forced to move a few entries into
|
||
the MIA (missing) section. I also removed one duplicate entry.
|
||
|
||
<p>New entries: <ref id="MASON">, <ref id="spyse">, <ref id="AntWars">,
|
||
<ref id="OpenSteer">, <ref id="Pyro">, <ref id="Robocode">,
|
||
<ref id="Trend"> and <ref id="Open BEAGLE">.
|
||
|
||
<item>v2.1 -
|
||
|
||
<p>New entries: <ref id="NLTK">, <ref id="NEURObjects">, <ref id="KANREN">,
|
||
<ref id="Neural Networks at your Fingertips">, <ref id="SimWorld">,
|
||
<ref id="SimAgent">, <ref id="Fuzzy sets for Ada">, <ref id="maxent">,
|
||
<ref id="Evo">, <ref id="breve"> and <ref id="AJA">
|
||
|
||
|
||
<item>v2.0 - Ran linkchecker and for any bad links I either found a new
|
||
link or removed the item. See the new section MIA for a list of the removed
|
||
entries (please let me know if you know of a new home for them).
|
||
|
||
<p>New entries: <ref id="Yale">, <ref id="DIET Agents">, <ref id="JASA">,
|
||
<ref id="Jason">, <ref id="Noble Ape">, Maude (removed),
|
||
ECLiPSe (removed), lush (removed), and <ref id="pygp">
|
||
|
||
<item>v1.9 - One new entry (<ref id="Bond">) and fixed the link below
|
||
to the dynamic list (now defunct).
|
||
|
||
<item>v1.8 - Cleaned up bad links, finding new ones where possible and
|
||
eliminating those that seem to have disappeared. Quite a few new entries as
|
||
well.
|
||
|
||
<p>New entries: <ref id="Torch">, <ref id="Aleph">, <ref id="AI Kernel">,
|
||
<ref id="OpenCyc">, <ref id="HTK">, <ref id="FFLL">, <ref id="JCK">,
|
||
<ref id="Joone">, <ref id="scnANNlib">, <ref id="GAUL">,
|
||
<ref id="Cougaar">, and <ref id="RoboTournament">
|
||
|
||
<item>v1.7 - Another 9 new entries, a bunch of links fixed, and a few items
|
||
removed that have vanished from the net.
|
||
|
||
<p>New entries: <ref id="SPASS">, <ref id="CNNs">, <ref id="JCASim">,
|
||
<ref id="Genetic">, <ref id="CAGE">, <ref id="AgentFarms">,
|
||
<ref id="MATREM">, <ref id="OAA">, and
|
||
<ref id="UTCS" name="UTCS Neural Nets Research Group Software">
|
||
|
||
<item>v1.6 - 9 new entries, a couple link fixes and one duplicate item
|
||
removed.
|
||
<item>v1.5 - 26 new entries plus a couple link fixes.
|
||
<item>v1.4 - 10 new updates and fixed some lisp-related links.
|
||
<item>v1.3 - Putting a dent in the backlog, I added 30+ new entries today
|
||
and submitted it to the LDP.
|
||
<item>Previous records were in a mixed format with site updates. See the
|
||
<htmlurl url="http://zhar.net/howto/oldnotes/" name="old notes">
|
||
section of the master site for them.
|
||
</itemize>
|
||
|
||
<sect1>Where to find this software
|
||
<p>
|
||
|
||
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
|
||
resources listed on the <htmlurl url="http://zhar.net/howto/ai_links/"
|
||
name="links section"> of the Master Site (given above).
|
||
|
||
|
||
<sect1>Updates and comments
|
||
<p>
|
||
|
||
If you find any mistakes, know of updates to one of the items below,
|
||
or have problems compiling any of the applications, please mail me at:
|
||
<htmlurl url="mailto:jae@zhar.net" name="jae@zhar.net">
|
||
and I'll see what I can do.
|
||
|
||
|
||
If you know of any AI/Alife applications, class libraries,
|
||
etc. <bf>Please</bf> <htmlurl url="mailto:jae@zhar.net" name=" 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.
|
||
|
||
<sect1>Copyright/License
|
||
<p>
|
||
|
||
<htmlurl url="http://creativecommons.org/publicdomain/zero/1.0/" name="CC0">
|
||
|
||
<p> To the extent possible under law, John Eikenberry has waived all copyright
|
||
and related or neighboring rights to this work. This work is published from:
|
||
United States.
|
||
|
||
|
||
<sect>Symbolic Systems (GOFAI)
|
||
|
||
<label id="Symbolic Systems (GOFAI)">
|
||
<p>
|
||
|
||
Traditionally AI was 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 though newer systems tend to use more
|
||
popular procedural languages. 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.
|
||
|
||
|
||
<sect1>AI class/code libraries
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
<label id="ACL2">
|
||
<tag/ACL2/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cliki.net/ACL2"
|
||
name="www.cliki.net/ACL2">
|
||
</itemize>
|
||
|
||
ACL2 (A Computational Logic for Applicative Common Lisp) is a theorem
|
||
prover for industrial applications. It is both a mathematical logic and
|
||
a system of tools for constructing proofs in the logic. ACL2 works
|
||
with GCL (GNU Common Lisp).
|
||
|
||
|
||
<label id="AI Kernel">
|
||
<tag/AI Kernel/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://aikernel.sourceforge.net/"
|
||
name="aikernel.sourceforge.net">
|
||
<item>Sourceforge site: <htmlurl
|
||
url="http://sourceforge.net/projects/aikernel/"
|
||
name="sourceforge.net/projects/aikernel/">
|
||
</itemize>
|
||
|
||
The AI Kernel is a re-usable artificial intelligence engine that uses
|
||
natural language processing and an Activator / Context model to allow
|
||
multi tasking between installed cells.
|
||
|
||
|
||
<label id="AI Search II">
|
||
<tag/AI Search II/
|
||
<itemize>
|
||
<item>WEB site: <htmlurl
|
||
url="http://www.neiu.edu/~kwtracy/ooai-book/">
|
||
</itemize>
|
||
|
||
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 <bf>C++</bf>'s features of derivation and inheritance. The
|
||
following search algorithms have been implemented:
|
||
|
||
|
||
<itemize>
|
||
<item>depth-first tree and graph search.</item>
|
||
<item>breadth-first tree and graph search.</item>
|
||
<item>uniform-cost tree and graph search.</item>
|
||
<item>best-first search.</item>
|
||
<item>bidirectional depth-first tree and graph search.</item>
|
||
<item>bidirectional breadth-first tree and graph search.</item>
|
||
<item>AND/OR depth tree search.</item>
|
||
<item>AND/OR breadth tree search.</item>
|
||
</itemize>
|
||
|
||
|
||
This library has a corresponding book, "<htmlurl
|
||
url="http://www.neiu.edu/~kwtracy/ooai-book/"
|
||
name="Object-Oriented Artificial Intelligence, Using C++">".
|
||
|
||
|
||
<label id="Alchemy">
|
||
<tag/Alchemy/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://alchemy.cs.washington.edu/">
|
||
</itemize>
|
||
|
||
Alchemy is a software package providing a series of algorithms for
|
||
statistical relational learning and probabilistic logic inference,
|
||
based on the Markov logic representation. Alchemy allows you to easily
|
||
develop a wide range of AI applications, including:
|
||
|
||
<itemize>
|
||
<item>Collective classification</item>
|
||
<item>Link prediction</item>
|
||
<item>Entity resolution</item>
|
||
<item>Social network modeling</item>
|
||
<item>Information extraction</item>
|
||
</itemize>
|
||
|
||
|
||
<label id="Aleph">
|
||
<tag/Aleph/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.ox.ac.uk/activities/machlearn/Aleph/">
|
||
</itemize>
|
||
|
||
This document provides reference information on A Learning Engine for
|
||
Proposing Hypotheses (Aleph). Aleph is an Inductive Logic Programming
|
||
(ILP) system. Aleph is intended to be a prototype for exploring ideas.
|
||
Aleph is an ILP algorithm implemented in Prolog by Dr Ashwin
|
||
Srinivasan at the Oxford University Computing Laboratory, and is
|
||
written specifically for compilation with the YAP Prolog compiler
|
||
|
||
|
||
<label id="CBR Microprograms">
|
||
<tag/Microprograms/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.indiana.edu/~leake/cbr/code/">
|
||
</itemize>
|
||
|
||
A collection of case-based reasoning "micro" versions of dissertation
|
||
programs that were developed for pedagogical purposes. These programs
|
||
are meant to distill key aspects of the original programs into a form
|
||
that can be easily understood, modified, and extended.
|
||
|
||
|
||
<label id="Chess In List">
|
||
<tag/Chess In Lisp (CIL)/
|
||
<itemize>
|
||
<item>Web site: *found as part of the CLOCC archive at: <htmlurl
|
||
url="http://clocc.sourceforge.net/"
|
||
name="clocc.sourceforge.net">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="clasp">
|
||
<tag/clasp/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.uni-potsdam.de/clasp/">
|
||
</itemize>
|
||
|
||
clasp is an answer set solver for (extended) normal logic programs. It
|
||
combines the high-level modeling capacities of answer set programming
|
||
(ASP) with state-of-the-art techniques from the area of Boolean
|
||
constraint solving. The primary clasp algorithm relies on
|
||
conflict-driven nogood learning, a technique that proved very
|
||
successful for satisfiability checking (SAT). Unlike other learning ASP
|
||
solvers, clasp does not rely on legacy software, such as a SAT solver
|
||
or any other existing ASP solver. Rather, clasp has been genuinely
|
||
developed for answer set solving based on conflict-driven nogood
|
||
learning. clasp can be applied as an ASP solver (on LPARSE output
|
||
format), as a SAT solver (on simplified DIMACS/CNF format), or as a PB
|
||
solver (on OPB format).
|
||
|
||
|
||
<label id="ConceptNet">
|
||
<tag/ConceptNet/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://conceptnet.media.mit.edu/">
|
||
<item>Old Web site: <htmlurl
|
||
url="http://web.media.mit.edu/~hugo/conceptnet/">
|
||
</itemize>
|
||
|
||
ConceptNet aims to give computers access to common-sense knowledge, the
|
||
kind of information that ordinary people know but usually leave
|
||
unstated. The data in ConceptNet was collected from ordinary people who
|
||
contributed it over the Web. ConceptNet represents this data in the
|
||
form of a semantic network, and makes it available to be used in
|
||
natural language processing and intelligent user interfaces.
|
||
|
||
This API provides Python code with access to both ConceptNet 3 and the
|
||
development database that will become ConceptNet 4, and the natural
|
||
language tools necessary to work with it. It uses Django for
|
||
interacting with the database.
|
||
|
||
|
||
<label id="ERESYE">
|
||
<tag/ERESYE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/eresye/">
|
||
<item>Tutorial: <htmlurl
|
||
url="http://www.trapexit.org/Artificial_Intelligence_with_Erlang:_the_Domain_of_Relatives">
|
||
</itemize>
|
||
|
||
ERESYE means ERlang Expert SYstem Engine. It is a library to write
|
||
expert systems and rule processing engines using the Erlang programming
|
||
language. It allows to create multiple engines, each one with its own
|
||
facts and rules to be processed.
|
||
|
||
|
||
<label id="FFLL">
|
||
<tag/FFLL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ffll.sourceforge.net/"
|
||
name="ffll.sourceforge.net">
|
||
</itemize>
|
||
|
||
The Free Fuzzy Logic Library (FFLL) is an open source fuzzy logic class
|
||
library and API that is optimized for speed critical applications, such
|
||
as video games. FFLL is able to load files that adhere to the IEC
|
||
61131-7 standard.
|
||
|
||
|
||
<label id="FLiP">
|
||
<tag/FLiP/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://staff.washington.edu/jon/flip/www/">
|
||
</itemize>
|
||
|
||
Flip is a logical framework written in Python. A logical framework is a
|
||
library for defining logics and writing applications such as theorem
|
||
provers. The checker can use different logics; Flip comes with several.
|
||
You can add another logic, or add axioms and derived rules, by writing
|
||
a module in Python. Python is both the object language and the
|
||
metalanguage. Formulas, inference rules, and entire proofs are Python
|
||
expressions. Prover commands are Python functions.
|
||
|
||
|
||
<label id="Fuzzy sets for Ada">
|
||
<tag/Fuzzy sets for Ada/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.dmitry-kazakov.de/ada/fuzzy.htm">
|
||
<item>Freshmeat: <htmlurl
|
||
url="http://freshmeat.net/projects/fuzzy/">
|
||
</itemize>
|
||
|
||
Fuzzy sets for Ada is a library providing implementations of confidence
|
||
factors with the operations not, and, or, xor, +, and *, classical
|
||
fuzzy sets with the set-theoretic operations and the operations of the
|
||
possibility theory, intuitionistic fuzzy sets with the operations on
|
||
them, fuzzy logic based on the intuitionistic fuzzy sets and the
|
||
possibility theory; fuzzy numbers, both integer and floating-point with
|
||
conventional arithmetical operations, and linguistic variables and sets
|
||
of linguistic variables with operations on them. String-oriented I/O
|
||
is supported.
|
||
|
||
|
||
<label id="HTK">
|
||
<tag/HTK/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://htk.eng.cam.ac.uk/"
|
||
name="htk.eng.cam.ac.uk">
|
||
</itemize>
|
||
|
||
The Hidden Markov Model Toolkit (HTK) is a portable toolkit for
|
||
building and manipulating hidden Markov models. HTK consists of a set
|
||
of library modules and tools available in C source form. The tools
|
||
provide sophisticated facilities for speech analysis, HMM training,
|
||
testing and results analysis. The software supports HMMs using both
|
||
continuous density mixture Gaussians and discrete distributions and can
|
||
be used to build complex HMM systems. The HTK release contains
|
||
extensive documentation and examples.
|
||
|
||
|
||
<label id="JCK">
|
||
<tag/JCK/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.pms.informatik.uni-muenchen.de/software/jack/"
|
||
name="www.pms.informatik.uni-muenchen.de/software/jack/">
|
||
</itemize>
|
||
|
||
JCK is a new library providing constraint programming and search for
|
||
Java.
|
||
<itemize>
|
||
JCK consists of three components:
|
||
<item>
|
||
- JCHR: Java Constraint Handling Rules.
|
||
A high-level language to write constraint solvers.
|
||
<item>
|
||
- JASE: Java Abstract Search Engine.
|
||
A generic search engine for JCHR to solve constraint
|
||
problems.
|
||
<item>
|
||
- VisualCHR:
|
||
An interactive tool to visualize JCHR computations.
|
||
</itemize>
|
||
Source and documentation available from link above.
|
||
|
||
|
||
<label id="KANREN">
|
||
<tag/KANREN/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://kanren.sourceforge.net/"
|
||
name="kanren.sourceforge.net">
|
||
</itemize>
|
||
|
||
KANREN is a declarative logic programming system with first-class
|
||
relations, embedded in a pure functional subset of Scheme. The system
|
||
has a set-theoretical semantics, true unions, fair scheduling,
|
||
first-class relations, lexically-scoped logical variables, depth-first
|
||
and iterative deepening strategies. The system achieves high
|
||
performance and expressivity without cuts.
|
||
|
||
|
||
<label id="LK">
|
||
<tag/LK/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.utoronto.ca/˜neto/research/lk/"
|
||
name="www.cs.utoronto.ca/˜neto/research/lk/">
|
||
</itemize>
|
||
|
||
LK is an implementation of the Lin-Kernighan heuristic for the
|
||
Traveling Salesman Problem and for the minimum weight perfect matching
|
||
problem. It is tuned for 2-d geometric instances, and has been applied
|
||
to certain instances with up to a million cities. Also included are
|
||
instance generators and Perl scripts for munging TSPLIB instances.
|
||
|
||
This implementation introduces ``efficient cluster compensation'', an
|
||
experimental algorithmic technique intended to make the Lin-Kernighan
|
||
heuristic more robust in the face of clustered data.
|
||
|
||
|
||
<label id="LingPipe">
|
||
<tag/LingPipe/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://alias-i.com/lingpipe/">
|
||
</itemize>
|
||
|
||
LingPipe is a state-of-the-art suite of natural language processing
|
||
tools written in Java that performs tokenization, sentence detection,
|
||
named entity detection, coreference resolution, classification,
|
||
clustering, part-of-speech tagging, general chunking, fuzzy dictionary
|
||
matching.
|
||
|
||
|
||
<label id="Logfun">
|
||
<tag/Logfun/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.irisa.fr/lande/ferre/logfun/">
|
||
</itemize>
|
||
|
||
Logfun is a library of logic functors. A logic functor is a
|
||
function that can be applied to zero, one or several logics so as
|
||
to produce a new logic as a combination of argument logics. Each
|
||
argument logic can itself be built by combination of logic
|
||
functors. The signature of a logic is made of a parser and a
|
||
printer of formulas, logical operations such as a theorem prover
|
||
for entailment between formulas, and more specific operations
|
||
required by Logical Information Systems (LIS). Logic functors can
|
||
be concrete domains like integers, strings, or algebraic
|
||
combinators like product or sum of logics.
|
||
|
||
Logic functors are coded as Objective Caml modules. A logic
|
||
semantics is associated to each of these logic functors. This
|
||
enables to define properties of logics like the consistency and
|
||
completeness of the entailment prover, and to prove under which
|
||
conditions a generated entailement prover satisfies these
|
||
properties given the properties of argument logics.
|
||
|
||
|
||
<label id="Loom">
|
||
<tag/Loom/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.isi.edu/isd/LOOM/">
|
||
</itemize>
|
||
|
||
* Note: Loom has been succeeded by <ref id="PowerLoom">.
|
||
|
||
Loom is a language and environment for constructing intelligent
|
||
applications. The heart of Loom is a knowledge representation system
|
||
that is used to provide deductive support for the declarative portion
|
||
of the Loom language. Declarative knowledge in Loom consists of
|
||
definitions, rules, facts, and default rules. A deductive engine called
|
||
a classifier utilizes forward-chaining, semantic unification and
|
||
object-oriented truth maintainance technologies in order to compile the
|
||
declarative knowledge into a network designed to efficiently support
|
||
on-line deductive query processing.
|
||
|
||
The Loom system implements a logic-based pattern matcher that drives a
|
||
production rule facility and a pattern-directed method dispatching
|
||
facility that supports the definition of object-oriented methods. The
|
||
high degree of integration between Loom's declarative and procedural
|
||
components permits programmers to utilize logic programming, production
|
||
rule, and object-oriented programming paradigms in a single
|
||
application. Loom can also be used as a deductive layer that overlays
|
||
an ordinary CLOS network. In this mode, users can obtain many of the
|
||
benefits of using Loom without impacting the function or performance of
|
||
their CLOS-based applications.
|
||
|
||
|
||
<label id="maxent">
|
||
<tag/maxent/
|
||
<itemize>
|
||
<item>Python/C++ version: <htmlurl
|
||
url="http://homepages.inf.ed.ac.uk/lzhang10/maxent_toolkit.html"
|
||
name="http://homepages.inf.ed.ac.uk/lzhang10/maxent_toolkit.html">
|
||
<item>Java version: <htmlurl
|
||
url="http://maxent.sourceforge.net/"
|
||
name="maxent.sourceforge.net">
|
||
</itemize>
|
||
|
||
The Maximum Entropy Toolkit provides a set of tools and library for
|
||
constructing maximum entropy (maxent) models in either Python or C++.
|
||
Maxent Entropy Model is a general purpose machine learning framework
|
||
that has proved to be highly expressive and powerful in statistical
|
||
natural language processing, statistical physics, computer vision and
|
||
many other fields.
|
||
|
||
It features conditional maximum entropy models, L-BFGS and GIS
|
||
parameter estimation, Gaussian Prior smoothing, a C++ API, a Python
|
||
extension module, a command line utility, and good documentation. A
|
||
Java version is also available.
|
||
|
||
|
||
<label id="Nyquist">
|
||
<tag/Nyquist/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www-2.cs.cmu.edu/~music/nyquist/"
|
||
name="www-2.cs.cmu.edu/~music/nyquist/">
|
||
</itemize>
|
||
|
||
The Computer Music Project at CMU is developing computer music
|
||
and interactive performance technology to enhance human musical
|
||
experience and creativity. This interdisciplinary effort draws
|
||
on Music Theory, Cognitive Science, Artificial Intelligence and
|
||
Machine Learning, Human Computer Interaction, Real-Time Systems,
|
||
Computer Graphics and Animation, Multimedia, Programming
|
||
Languages, and Signal Processing. A paradigmatic example of
|
||
these interdisciplinary efforts is the creation of interactive
|
||
performances that couple human musical improvisation with
|
||
intelligent computer agents in real-time.
|
||
|
||
|
||
<label id="OpenCyc">
|
||
<tag/OpenCyc/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.opencyc.org/">
|
||
<item>Alt Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/opencyc/">
|
||
</itemize>
|
||
|
||
OpenCyc is the open source version of Cyc, the largest and most
|
||
complete general knowledge base and commonsense reasoning engine. An
|
||
ontology based on 6000 concepts and 60000 assertions about them.
|
||
|
||
|
||
<label id="Pattern">
|
||
<tag/Pattern/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.clips.ua.ac.be/pages/pattern">
|
||
</itemize>
|
||
|
||
Pattern is a web mining module for the Python programming language. It
|
||
bundles tools for data retrieval (Google + Twitter + Wikipedia API, web
|
||
spider, HTML DOM parser), text analysis (rule-based shallow parser,
|
||
WordNet interface, syntactical + semantical n-gram search algorithm,
|
||
tf-idf + cosine similarity + LSA metrics) and data visualization (graph
|
||
networks).
|
||
|
||
|
||
<label id="PowerLoom">
|
||
<tag/PowerLoom/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.isi.edu/isd/LOOM/PowerLoom/">
|
||
</itemize>
|
||
|
||
PowerLoom is the successor to the <ref id="Loom"> knowledge
|
||
representation system. It provides a language and environment for
|
||
constructing intelligent, knowledge-based applications. PowerLoom uses
|
||
a fully expressive, logic-based representation language (a variant of
|
||
KIF). It uses a natural deduction inference engine that combines
|
||
forward and backward chaining to derive what logically follows from the
|
||
facts and rules asserted in the knowledge base. While PowerLoom is not
|
||
a description logic, it does have a description classifier which uses
|
||
technology derived from the Loom classifier to classify descriptions
|
||
expressed in full first order predicate calculus (see paper). PowerLoom
|
||
uses modules as a structuring device for knowledge bases, and
|
||
ultra-lightweight worlds to support hypothetical reasoning.
|
||
|
||
To implement PowerLoom we developed a new programming language called
|
||
STELLA, which is a Strongly Typed, Lisp-like LAnguage that can be
|
||
translated into Lisp, C++ and Java. PowerLoom is written in STELLA and
|
||
therefore available in Common-Lisp, C++ and Java versions.
|
||
|
||
|
||
<label id="PyCLIPS">
|
||
<tag/PyCLIPS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://pyclips.sourceforge.net/web/">
|
||
</itemize>
|
||
|
||
PyCLIPS is an extension module for the Python language that embeds full
|
||
CLIPS functionality in Python applications. This means that you can
|
||
provide Python with a strong, reliable, widely used and well documented
|
||
inference engine.
|
||
|
||
|
||
<label id="Pyke">
|
||
<tag/Pyke/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://pyke.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Pyke is a knowledge-based inference engine (expert system) written in
|
||
100% python that can:
|
||
|
||
<itemize>
|
||
<item> Do both forward-chaining (data driven) and backward-chaining
|
||
(goal directed) inferencing.
|
||
<itemize>
|
||
<item> Pyke may be embedded into any python program.
|
||
</itemize>
|
||
|
||
<item> Automatically generate python programs by assembling
|
||
individual python functions into complete call graphs.
|
||
|
||
<itemize>
|
||
|
||
<item> This is done through a unique design where the individual
|
||
python functions are attached to backward-chaining rules.
|
||
|
||
<item> Unlike other approaches to code reuse (e.g. Zope adapters
|
||
and generic functions), this allows the inference engine to ensure
|
||
that all of the function's requirements are completely satisfied,
|
||
by examining the entire call graph down to the leaves, before any
|
||
of the functions are executed.
|
||
|
||
<item> This is an optional feature. You don't need to use it if you
|
||
just want the inferencing capability by itself.
|
||
|
||
</itemize>
|
||
</itemize>
|
||
|
||
|
||
<label id="python-dlp">
|
||
<tag/python-dlp/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://code.google.com/p/python-dlp/">
|
||
</itemize>
|
||
|
||
python-dlp aims to be a contemporary expert system based on the
|
||
Semantic Web technologies. Traditionally, expert systems are an
|
||
application of computing and artificial intelligence with the aim
|
||
of supporting software that attempts to reproduce the deterministic
|
||
behavior of one or more human experts in a specific problem domain.
|
||
It utilizes the efficient RETE_UL algorithm as the 'engine' for the
|
||
expert system
|
||
|
||
|
||
<label id="Reverend">
|
||
<tag/Reverend/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/reverend/">
|
||
</itemize>
|
||
|
||
Reverned is a general purpose Bayesian classifier written in Python. It
|
||
is designed to be easily extended to any application domain.
|
||
|
||
|
||
<label id="Screamer">
|
||
<tag/Screamer/
|
||
<itemize>
|
||
<item>Latest version is part of CLOCC: <htmlurl
|
||
url="http://clocc.sourceforge.net/"
|
||
name="clocc.sourceforge.net">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="SimpleAI">
|
||
<tag/SimpleAI/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="https://github.com/simpleai-team/simpleai">
|
||
</itemize>
|
||
|
||
Python library that implements many of the artificial intelligence
|
||
algorithms described on the book "Artificial Intelligence, a Modern
|
||
Approach", from Stuart Russel and Peter Norvig. Emphasis on creating a
|
||
stable, modern, and maintainable version. We are testing the majority
|
||
of the lib, it's available via pip install, has a standard repo and lib
|
||
architecture, well documented, respects the python pep8 guidelines,
|
||
provides only working code (no placeholders for future things), etc.
|
||
Even the internal code is written with readability in mind, not only
|
||
the external API.
|
||
|
||
There is also <htmlurl url="https://code.google.com/p/aima-python/">
|
||
which implements these algorithms as well. Though it hasn't seen
|
||
activity in a while.
|
||
|
||
|
||
<label id="SPASS">
|
||
<tag/SPASS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.spass-prover.org/">
|
||
</itemize>
|
||
|
||
SPASS: An Automated Theorem Prover for First-Order Logic with Equality
|
||
|
||
If you are interested in first-order logic theorem proving, the formal
|
||
analysis of software, systems, protocols, formal approaches to AI
|
||
planning, decision procedures, modal logic theorem proving, SPASS may
|
||
offer you the right functionality.
|
||
|
||
|
||
</descrip>
|
||
|
||
|
||
<sect1>AI software kits, applications, etc.
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
<label id="ASA">
|
||
<tag/ASA - Adaptive Simulated Annealing/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.ingber.com/#ASA-CODE">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
<label id="Babylon">
|
||
<tag/Babylon/
|
||
<itemize>
|
||
<item>Archive: <htmlurl
|
||
url="http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/expert/systems/babylon/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="cfengine">
|
||
<tag/cfengine/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.iu.hio.no/cfengine/"
|
||
name="www.iu.hio.no/cfengine/">
|
||
</itemize>
|
||
|
||
Cfengine, or the configuration engine is a very high level language for
|
||
building expert systems which administrate and configure large computer
|
||
networks. Cfengine uses the idea of classes and a primitive form of
|
||
intelligence to define and automate the configuration of large systems
|
||
in the most economical way possible. Cfengine is design to be a part of
|
||
computer immune systems.
|
||
|
||
|
||
<label id="CLIPS">
|
||
<tag/CLIPS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://clipsrules.sourceforge.net/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="EMA-XPS">
|
||
<tag/EMA-XPS - A Hybrid Graphic Expert System Shell/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ema-xps.org/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Eprover">
|
||
<tag/Eprover/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.eprover.org/"
|
||
name="http://www.eprover.org/">
|
||
<item>Web site: <htmlurl
|
||
url="http://www4.informatik.tu-muenchen.de/˜schulz/WORK/eprover.html"
|
||
name="http://www4.informatik.tu-muenchen.de/˜schulz/WORK/eprover.html">
|
||
</itemize>
|
||
|
||
The E Equational Theorem Prover is a purely equational theorem prover.
|
||
The core proof procedure operates on formulas in clause normal form,
|
||
using a calculus that combines superposition (with selection of negative
|
||
literals) and rewriting. No special rules for non-equational literals
|
||
have been implemented, i.e., resolution is simulated via paramodulation
|
||
and equality resolution. The basic calculus is extended with rules for AC
|
||
redundancy elemination, some contextual simplification, and
|
||
pseudo-splitting. The latest version of E also supports simultaneous
|
||
paramodulation, either for all inferences or for selected inferences.
|
||
|
||
E is based on the DISCOUNT-loop variant of the given-clause algorithm,
|
||
i.e. a strict separation of active and passive facts. Proof search in E
|
||
is primarily controlled by a literal selection strategy, a clause
|
||
evaluation heuristic, and a simplification ordering. The prover supports
|
||
a large number of preprogrammed literal selection strategies, many of
|
||
which are only experimental. Clause evaluation heuristics can be
|
||
constructed on the fly by combining various parameterized primitive
|
||
evaluation functions, or can be selected from a set of predefined
|
||
heuristics. Supported term orderings are several parameterized instances
|
||
of Knuth-Bendix-Ordering (KBO) and Lexicographic Path Ordering (LPO).
|
||
|
||
|
||
<label id="Fool-Fox">
|
||
<tag/FOOL & FOX/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://rhaug.de/fool/"
|
||
name="rhaug.de/fool/">
|
||
<item>FTP site: <htmlurl
|
||
url="ftp://ftp.informatik.uni-oldenburg.de/pub/fool/"
|
||
name="ftp.informatik.uni-oldenburg.de/pub/fool/">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
<label id="FreeHAL">
|
||
<tag/FreeHAL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="https://freehal.net">
|
||
</itemize>
|
||
|
||
FreeHAL is a self-learning conversation simulator which uses semantic
|
||
nets to organize its knowledge.
|
||
|
||
FreeHAL uses a semantic network, pattern matching, stemmers, part of
|
||
speech databases, part of speech taggers, and Hidden Markov Models.
|
||
Both the online and the download version support TTS.
|
||
|
||
|
||
<label id="FUF-SURGE">
|
||
<tag/FUF and SURGE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.bgu.ac.il/surge/index.html">
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item>Types and inheritance.
|
||
<item>Extended control facilities (goal freezing, intelligent
|
||
backtracking).
|
||
<item>Modular syntax.
|
||
</itemize>
|
||
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.
|
||
|
||
|
||
<label id="GATE">
|
||
<tag/GATE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://gate.ac.uk/">
|
||
<item>Alt site: <htmlurl
|
||
url="http://sourceforge.net/projects/gate">
|
||
</itemize>
|
||
|
||
GATE (General Architecture for Text Engineering) is an architecture,
|
||
framework and development environment for developing, evaluating and
|
||
embedding Human Language Technology.
|
||
|
||
GATE is made up of three elements:
|
||
<itemize>
|
||
<item>An architecture describing how language processing systems are
|
||
made up of components.
|
||
<item>A framework (or class library, or SDK), written in Java and
|
||
tested on Linux, Windoze and Solaris.
|
||
<item>A graphical development environment built on the framework.
|
||
</itemize>
|
||
|
||
|
||
<label id="Grammar Workbench">
|
||
<tag/The Grammar Workbench/
|
||
<itemize>
|
||
<item>Web site: ??? <htmlurl
|
||
url="http://www.cs.kun.nl/agfl/"
|
||
name="www.cs.kun.nl/agfl/">
|
||
</itemize>
|
||
|
||
Seems to be obsolete??? Its gone from the site, though its parent
|
||
project is still ongoing.
|
||
|
||
The Grammar Workbench, or GWB for short, is an environment for the
|
||
comfortable development of Affix Grammars in the AGFL-formalism. Its
|
||
purposes are:
|
||
<itemize>
|
||
<item>to allow the user to input, inspect and modify a grammar;
|
||
<item>to perform consistency checks on the grammar;
|
||
<item>to compute grammar properties;
|
||
<item>to generate example sentences;
|
||
<item>to assist in performing grammar transformations.
|
||
</itemize>
|
||
|
||
|
||
<label id="GSM Suite">
|
||
<tag/GSM Suite/
|
||
<itemize>
|
||
<item>Alt site: <htmlurl
|
||
url="http://www.ibiblio.org/pub/Linux/apps/graphics/draw/"
|
||
name="www.ibiblio.org/pub/Linux/apps/graphics/draw/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Isabelle">
|
||
<tag/Isabelle/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://isabelle.in.tum.de/"
|
||
name="isabelle.in.tum.de">
|
||
</itemize>
|
||
|
||
Isabelle is a popular generic theorem prover developed at Cambridge
|
||
University and TU Munich. Existing logics like Isabelle/HOL provide a
|
||
theorem proving environment ready to use for sizable applications.
|
||
Isabelle may also serve as framework for rapid prototyping of deductive
|
||
systems. It comes with a large library including Isabelle/HOL
|
||
(classical higher-order logic), Isabelle/HOLCF (Scott's Logic for
|
||
Computable Functions with HOL), Isabelle/FOL (classical and
|
||
intuitionistic first-order logic), and Isabelle/ZF (Zermelo-Fraenkel
|
||
set theory on top of FOL).
|
||
|
||
|
||
<label id="Jess">
|
||
<tag/Jess, the Java Expert System Shell/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://herzberg.ca.sandia.gov/jess/"
|
||
name="herzberg.ca.sandia.gov/jess/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="learn">
|
||
<tag/learn/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.ibiblio.org/pub/Linux/apps/cai/"
|
||
name="www.ibiblio.org/pub/Linux/apps/cai/">
|
||
</itemize>
|
||
|
||
Learn is a vocable learning program with memory model.
|
||
|
||
|
||
<label id="LISA">
|
||
<tag/LISA/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://lisa.sourceforge.net/"
|
||
name="lisa.sourceforge.net">
|
||
</itemize>
|
||
|
||
LISA (Lisp-based Intelligent Software Agents) is a production-rule
|
||
system heavily influenced by JESS (Java Expert System Shell). It has at
|
||
its core a reasoning engine based on the Rete pattern matching
|
||
algorithm. LISA also provides the ability to reason over ordinary CLOS
|
||
objects.
|
||
|
||
|
||
<label id="Livingstone2">
|
||
<tag/Livingstone2/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ti.arc.nasa.gov/opensource/projects/livingstone2/">
|
||
</itemize>
|
||
|
||
Livingstone2 (L2) is a reusable artificial intelligence (AI) software
|
||
system designed to assist spacecraft, life support systems, chemical
|
||
plants or other complex systems in operating robustly with minimal
|
||
human supervision, even in the face of hardware failures or unexpected
|
||
events.
|
||
|
||
|
||
<label id="NICOLE">
|
||
<tag/NICOLE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://nicole.sourceforge.net/">
|
||
</itemize>
|
||
|
||
NICOLE (Nearly Intelligent Computer Operated Language Examiner) is a
|
||
theory or experiment that if a computer is given enough combinations of
|
||
how words, phrases and sentences are related to one another, it could
|
||
talk back to you. It is an attempt to simulate a conversation by
|
||
learning how words are related to other words. A human communicates
|
||
with NICOLE via the keyboard and NICOLE responds back with its own
|
||
sentences which are automatically generated, based on what NICOLE has
|
||
stored in it's database. Each new sentence that has been typed in, and
|
||
NICOLE doesn't know about, is included into NICOLE's database, thus
|
||
extending the knowledge base of NICOLE.
|
||
|
||
|
||
<label id="Otter">
|
||
<tag/Otter: An Automated Deduction System/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www-unix.mcs.anl.gov/AR/otter/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="PVS">
|
||
<tag/PVS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://pvs.csl.sri.com/" name="pvs.csl.sri.com/">
|
||
</itemize>
|
||
|
||
PVS is a verification system: that is, a specification language
|
||
integrated with support tools and a theorem prover. It is
|
||
intended to capture the state-of-the-art in mechanized formal
|
||
methods and to be sufficiently rugged that it can be used for
|
||
significant applications. PVS is a research prototype: it
|
||
evolves and improves as we develop or apply new capabilities,
|
||
and as the stress of real use exposes new requirements.
|
||
|
||
|
||
<label id="SNePS">
|
||
<tag/SNePS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cse.buffalo.edu/sneps/"
|
||
name="www.cse.buffalo.edu/sneps/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Soar">
|
||
<tag/Soar/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sitemaker.umich.edu/soar"
|
||
name="sitemaker.umich.edu/soar">
|
||
</itemize>
|
||
|
||
|
||
Soar has been developed to be a general cognitive architecture.
|
||
We intend ultimately to enable the Soar architecture to:
|
||
<itemize>
|
||
<item>work on the full range of tasks expected of an
|
||
intelligent agent, from highly routine to extremely difficult,
|
||
open-ended problems
|
||
<item>represent and use appropriate forms of knowledge, such as
|
||
procedural, declarative, episodic, and possibly iconic
|
||
<item>employ the full range of problem solving methods
|
||
<item>interact with the outside world and
|
||
<item>learn about all aspects of the tasks and its performance on them.
|
||
</itemize>
|
||
In other words, our intention is for Soar to support all the
|
||
capabilities required of a general intelligent agent.
|
||
|
||
<label id="TCM">
|
||
<tag/TCM/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://wwwhome.cs.utwente.nl/˜tcm/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Yale">
|
||
<tag/Yale/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://yale.sf.net/"
|
||
name="yale.sf.net/">
|
||
<item>Alt Web site: <htmlurl
|
||
url="http://rapid-i.com/"
|
||
name="rapid-i.com/">
|
||
</itemize>
|
||
|
||
YALE (Yet Another Learning Environment) is an environment for machine
|
||
learning experiments. Experiments can be made up of a large number of
|
||
arbitrarily nestable operators and their setup is described by XML
|
||
files which can easily created with a graphical user interface.
|
||
Applications of YALE cover both research and real-world learning tasks.
|
||
|
||
|
||
<label id="WEKA">
|
||
<tag/WEKA/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.waikato.ac.nz/˜ml/"
|
||
name="lucy.cs.waikato.ac.nz/˜ml/">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
</descrip>
|
||
|
||
|
||
|
||
<sect>Connectionism
|
||
<label id="Connectionism">
|
||
<p>
|
||
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.
|
||
|
||
|
||
<sect1>Connectionist class/code libraries
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
<label id="Baysian Modeling">
|
||
<tag/Software for Flexible Bayesian Modeling/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.cs.utoronto.ca/˜radford/fbm.software.html">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="BELIEF">
|
||
<tag/BELIEF/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/reasonng/probabl/belief/">
|
||
</itemize>
|
||
|
||
|
||
BELIEF is a Common Lisp implementation of the Dempster and Kong
|
||
fusion and propagation algorithm for Graphical Belief Function
|
||
Models and the Lauritzen and Spiegelhalter algorithm for
|
||
Graphical Probabilistic Models. It includes code for
|
||
manipulating graphical belief models such as Bayes Nets and
|
||
Relevance Diagrams (a subset of Influence Diagrams) using both
|
||
belief functions and probabilities as basic representations of
|
||
uncertainty. It uses the Shenoy and Shafer version of the
|
||
algorithm, so one of its unique features is that it supports
|
||
both probability distributions and belief functions. It also
|
||
has limited support for second order models (probability
|
||
distributions on parameters).
|
||
|
||
<label id="bpnn.py">
|
||
<tag/bpnn.py/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://arctrix.com/nas/python/bpnn.py">
|
||
</itemize>
|
||
|
||
A simple back-propogation ANN in Python.
|
||
|
||
|
||
<label id="brain">
|
||
<tag/brain/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://harthur.github.com/brain/">
|
||
</itemize>
|
||
|
||
Brain is a lightweight JavaScript library for neural networks. It
|
||
implements the standard feedforward multi-layer perceptron neural
|
||
network trained with backpropagation.
|
||
|
||
<label id="brain-simulator">
|
||
<tag/brain-simulator/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.briansimulator.org/">
|
||
</itemize>
|
||
|
||
Brian is a clock-driven simulator for spiking neural networks. It is
|
||
designed with an emphasis on flexibility and extensibility, for rapid
|
||
development and refinement of neural models. Neuron models are
|
||
specified by sets of user-specified differential equations, threshold
|
||
conditions and reset conditions (given as strings). The focus is
|
||
primarily on networks of single compartment neuron models (e.g. leaky
|
||
integrate-and-fire or Hodgkin-Huxley type neurons). It is written in
|
||
Python and is easy to learn and use, highly flexible and easily
|
||
extensible. Features include:
|
||
|
||
<itemize>
|
||
<item>a system for specifying quantities with physical dimensions
|
||
<item>exact numerical integration for linear differential equations
|
||
<item>Euler, Runge-Kutta and exponential Euler integration for
|
||
nonlinear differential equations
|
||
<item>synaptic connections with delays
|
||
<item>short-term and long-term plasticity (spike-timing dependent
|
||
plasticity)
|
||
<item>a library of standard model components, including
|
||
integrate-and-fire equations, synapses and ionic currents
|
||
<item>a toolbox for automatically fitting spiking neuron models to
|
||
electrophysiological recordings
|
||
</itemize>
|
||
|
||
|
||
<label id="CNNs">
|
||
<tag/CNNs/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.isiweb.ee.ethz.ch/haenggi/CNNsim.html">
|
||
<item>Newer Version: <htmlurl
|
||
url="http://www.isiweb.ee.ethz.ch/haenggi/CNNsim_adv_manual.html">
|
||
<item>Old Page: <htmlurl
|
||
url="http://www.ce.unipr.it/research/pardis/CNN/cnn.html">
|
||
</itemize>
|
||
|
||
Cellular Neural Networks (CNN) is a massive parallel computing
|
||
paradigm defined in discrete N-dimensional spaces. A visualizing CNN
|
||
Simulator which allows to track the way in which the state trajectories
|
||
evolve, thus gaining an insight into the behavior of CNN dynamics.
|
||
This may be useful for forming an idea how a CNN 'works', especially
|
||
for those people who are not experienced in CNN theory.
|
||
|
||
|
||
<label id="CONICAL">
|
||
<tag/CONICAL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://strout.net/conical/">
|
||
</itemize>
|
||
|
||
CONICAL is a C++ class library for building simulations common
|
||
in computational neuroscience. Currently its focus is on
|
||
compartmental modeling, with capabilities similar to GENESIS and
|
||
NEURON. A model neuron is built out of compartments, usually
|
||
with a cylindrical shape. When small enough, these open-ended
|
||
cylinders can approximate nearly any geometry. Future classes
|
||
may support reaction-diffusion kinetics and more. A key feature
|
||
of CONICAL is its cross-platform compatibility; it has been
|
||
fully co-developed and tested under Unix, DOS, and Mac OS.
|
||
|
||
|
||
<label id="Encog">
|
||
<tag/Encog/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.heatonresearch.com/">
|
||
</itemize>
|
||
|
||
Encog is an advanced neural network and machine learning framework.
|
||
Encog contains classes to create a wide variety of networks, as well as
|
||
support classes to normalize and process data for these neural
|
||
networks. Encog trains using multithreaded resilient propagation. Encog
|
||
can also make use of a GPU to further speed processing time. A GUI
|
||
based workbench is also provided to help model and train neural
|
||
networks. Encog has been in active development since 2008. Encog is
|
||
available for Java, .Net and Silverlight.
|
||
|
||
|
||
<label id="FANN">
|
||
<tag/FANN/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://leenissen.dk/fann/">
|
||
</itemize>
|
||
|
||
Fast Artificial Neural Network Library is a free open source neural
|
||
network library, which implements multilayer artificial neural networks
|
||
in C with support for both fully connected and sparsely connected
|
||
networks. Cross-platform execution in both fixed and floating point are
|
||
supported. It includes a framework for easy handling of training data
|
||
sets. It is easy to use, versatile, well documented, and fast. PHP,
|
||
C++, .NET, Ada, Python, Delphi, Octave, Ruby, Prolog Pure Data and
|
||
Mathematica bindings are available. A reference manual accompanies the
|
||
library with examples and recommendations on how to use the library. A
|
||
graphical user interface is also available for the library.
|
||
|
||
|
||
<label id="ffnet">
|
||
<tag/ffnet/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://ffnet.sourceforge.net/">
|
||
</itemize>
|
||
|
||
ffnet is a fast and easy-to-use feed-forward neural network training
|
||
solution for python. Many nice features are implemented: arbitrary
|
||
network connectivity, automatic data normalization, very efficient
|
||
training tools, network export to fortran code.
|
||
|
||
|
||
<label id="Joone">
|
||
<tag/Joone/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/joone/">
|
||
</itemize>
|
||
|
||
Joone is a neural net framework to create, train and test neural nets.
|
||
The aim is to create a distributed environment based on JavaSpaces both
|
||
for enthusiastic and professional users, based on the newest Java
|
||
technologies. Joone is composed of a central engine that is the
|
||
fulcrum of all applications that already exist or will be developed.
|
||
The neural engine is modular, scalable, multitasking and tensile.
|
||
Everyone can write new modules to implement new algorithms or new
|
||
architectures starting from the simple components distributed with the
|
||
core engine. The main idea is to create the basis to promote a zillion
|
||
of AI applications that revolve around the core framework.
|
||
|
||
|
||
<label id="Matrix Class">
|
||
<tag/Matrix Class/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl url="ftp://ftp.cs.ucla.edu/pub/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="NEAT">
|
||
<tag/NEAT/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://nn.cs.utexas.edu/project-view.php?RECORD_KEY(Projects)=ProjID&ProjID(Projects)=14">
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.ucf.edu/˜kstanley/neat.html">
|
||
</itemize>
|
||
|
||
Many neuroevolution methods evolve fixed-topology networks. Some
|
||
methods evolve topologies in addition to weights, but these usually
|
||
have a bound on the complexity of networks that can be evolved and
|
||
begin evolution with random topologies. This project is based on a
|
||
neuroevolution method called NeuroEvolution of Augmenting Topologies
|
||
(NEAT) that can evolve networks of unbounded complexity from a minimal
|
||
starting point.
|
||
|
||
The research as a broader goal of showing that evolving topologies is
|
||
necessary to achieve 3 major goals of neuroevolution: (1) Continual
|
||
coevolution: Successful competitive coevolution can use the evolution
|
||
of topologies to continuously elaborate strategies. (2) Evolution of
|
||
Adaptive Networks: The evolution of topologies allows neuroevolution to
|
||
evolve adaptive networks with plastic synapses by designating which
|
||
connections should be adaptive and in what ways. (3) Combining Expert
|
||
Networks: Separate expert neural networks can be fused through the
|
||
evolution of connecting neurons between them.
|
||
|
||
|
||
<label id="NeuroLab">
|
||
<tag/NeuroLab/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://packages.python.org/neurolab/">
|
||
</itemize>
|
||
|
||
NeuroLab - a library of basic neural networks algorithms with flexible
|
||
network configurations and learning algorithms for Python. To simplify
|
||
the using of the library, interface is similar to the package of Neural
|
||
Network Toolbox (NNT) of MATLAB (c). The library is based on the
|
||
package numpy (http://numpy.scipy.org), some learning algorithms are
|
||
used scipy.optimize (http://scipy.org).
|
||
|
||
|
||
<label id="NuPIC">
|
||
<tag/NuPIC/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.numenta.org/">
|
||
<item>Web site: <htmlurl url="https://github.com/numenta/nupic">
|
||
</itemize>
|
||
|
||
The Numenta Platform for Intelligent Computing (NuPIC) is built around
|
||
Cortical learning algorithms, a new variation of HTM networks
|
||
(Hierarchical Temporal Memory). Based on Jeff Hawkins idea as laid out
|
||
in his On Intelligence book. NuPIC consists of the Numenta Tools
|
||
Framework and the Numenta Runtime Engine.
|
||
|
||
|
||
<label id="Pulcinella">
|
||
<tag/Pulcinella/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://iridia.ulb.ac.be/pulcinella/">
|
||
</itemize>
|
||
|
||
Pulcinella is written in CommonLisp, and appears as a library of
|
||
Lisp functions for creating, modifying and evaluating valuation
|
||
systems. Alternatively, the user can choose to interact with
|
||
Pulcinella via a graphical interface (only available in Allegro
|
||
CL). Pulcinella provides primitives to build and evaluate
|
||
uncertainty models according to several uncertainty calculi,
|
||
including probability theory, possibility theory, and
|
||
Dempster-Shafer's theory of belief functions; and the
|
||
possibility theory by Zadeh, Dubois and Prade's. A User's Manual
|
||
is available on request.
|
||
|
||
|
||
<label id="scnANNlib">
|
||
<tag/scnANNlib/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.sentinelchicken.org/projects/scnANNlib/">
|
||
</itemize>
|
||
|
||
SCN Artificial Neural Network Library provides a programmer with a
|
||
simple object-oriented API for constructing ANNs. Currently, the
|
||
library supports non-recursive networks with an arbitrary number of
|
||
layers, each with an arbitrary number of nodes. Facilities exist for
|
||
training with momentum, and there are plans to gracefully extend the
|
||
functionality of the library in later releases.
|
||
|
||
|
||
<label id="UTCS">
|
||
<tag/UTCS Neural Nets Research Group Software/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://nn.cs.utexas.edu/soft-list.php">
|
||
</itemize>
|
||
|
||
A bit different from the other entries, this is a reference to a
|
||
collection of software rather than one application. It was all
|
||
developed by the <htmlurl url="http://nn.cs.utexas.edu/" name="UTCS
|
||
Neural Net Research Group">. Here's a summary of some of the packages
|
||
available:
|
||
|
||
<itemize>
|
||
<item>Natural Language Processing
|
||
<itemize>
|
||
<item>MIR - Tcl/Tk-based rapid prototyping for sentence
|
||
processing
|
||
<item>SPEC - Parsing complex sentences
|
||
<item>DISCERN - Processing script-based stories, including
|
||
<itemize>
|
||
<item>PROC - Parsing, generation, question answering
|
||
<item>HFM - Episodic memory organization
|
||
<item>DISLEX - Lexical processing
|
||
<item>DISCERN - The full integrated model
|
||
</itemize>
|
||
<item>FGREPNET - Learning distributed representations
|
||
</itemize>
|
||
<item>Self-Organization
|
||
<itemize>
|
||
<item>LISSOM - Maps with self-organizing lateral connections.
|
||
<item>FM - Generic Self-Organizing Maps
|
||
</itemize>
|
||
<item>Neuroevolution
|
||
<itemize>
|
||
<item>Enforced Sub-Populations (ESP) for sequential decision
|
||
tasks
|
||
<itemize>
|
||
<item>Non-Markov Double Pole Balancing
|
||
</itemize>
|
||
<item>Symbiotic, Adaptive NeuroEvolution (SANE; predecessor of
|
||
ESP)
|
||
<itemize>
|
||
<item>JavaSANE - Java software package for applying SANE to
|
||
new tasks
|
||
<item>SANE-C - C version, predecessor of JavaSANE
|
||
<item>Pole Balancing - Neuron-level SANE on the Pole
|
||
Balancing task
|
||
</itemize>
|
||
<item>NeuroEvolution of Augmenting Topologies (NEAT)
|
||
software for evolving neural networks using structure
|
||
</itemize>
|
||
</itemize>
|
||
|
||
|
||
<label id="C++ ANNs">
|
||
<tag/Various (C++) Neural Networks/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.dontveter.com/nnsoft/nnsoft.html">
|
||
</itemize>
|
||
|
||
Example neural net codes from the book, <htmlurl
|
||
url="http://www.dontveter.com/basisofai/basisofai.html" name="The
|
||
Pattern Recognition Basics of AI">.
|
||
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++)
|
||
|
||
|
||
<itemize> <item>The Backprop Package
|
||
<item>The Nearest Neighbor Algorithms
|
||
<item>The Interactive Activation Algorithm
|
||
<item>The Hopfield and Boltzman machine Algorithms
|
||
<item>The Linear Pattern Classifier
|
||
<item>ART I
|
||
<item>Bi-Directional Associative Memory
|
||
<item>The Feedforward Counter-Propagation Network
|
||
</itemize>
|
||
|
||
|
||
</descrip>
|
||
|
||
<sect1>Connectionist software kits/applications
|
||
<p>
|
||
|
||
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.
|
||
<descrip>
|
||
|
||
|
||
<label id="Aspirin-MIGRANES">
|
||
<tag/Aspirin - MIGRAINES/ (am6.tar.Z on ftp site)
|
||
<itemize>
|
||
<item>FTP site: <htmlurl url="ftp://sunsite.unc.edu/pub/academic/computer-science/neural-networks/programs/Aspirin/">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
|
||
<label id="DDLab">
|
||
<tag/DDLab/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.ddlab.com/">
|
||
</itemize>
|
||
|
||
DDLab is an interactive graphics program for research into the
|
||
dynamics of finite binary networks, relevant to the study of
|
||
complexity, emergent phenomena, neural networks, and aspects of
|
||
theoretical biology such as gene regulatory networks. A network
|
||
can be set up with any architecture between regular CA (1d or
|
||
2d) and "random Boolean networks" (networks with arbitrary
|
||
connections and heterogeneous rules). The network may also have
|
||
heterogeneous neighborhood sizes.
|
||
|
||
|
||
<label id="Emergent">
|
||
<tag/Emergent/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://grey.colorado.edu/emergent/index.php/Main_Page">
|
||
</itemize>
|
||
|
||
Note: this is a descendant of <ref id="PDP++">
|
||
|
||
emergent is a comprehensive, full-featured neural network simulator
|
||
that allows for the creation and analysis of complex, sophisticated
|
||
models of the brain in the world. With an emphasis on qualitative
|
||
analysis and teaching, it also supports the workflow of professional
|
||
neural network researchers. The GUI environment allows users to quickly
|
||
construct basic networks, modify the input/output patterns,
|
||
automatically generate the basic programs required to train and test
|
||
the network, and easily utilize several data processing and network
|
||
analysis tools. In addition to the basic preset network train and test
|
||
programs, the high level drag-and-drop programming interface, built on
|
||
top of a scripting language that has full introspective access to all
|
||
aspects of networks and the software itself, allows one to write
|
||
programs that seamlessly weave together the training of a network and
|
||
evolution of its environment without ever typing out a line of code.
|
||
Networks and all of their state variables are visually inspected in 3D,
|
||
allowing for a quick "visual regression" of network dynamics and robot
|
||
behavior.
|
||
|
||
|
||
<label id="GENESIS">
|
||
<tag/GENESIS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://genesis-sim.org/">
|
||
</itemize>
|
||
|
||
GENESIS (short for GEneral NEural SImulation System) is a
|
||
general purpose simulation platform which was developed to
|
||
support the simulation of neural systems ranging from complex
|
||
models of single neurons to simulations of large networks made
|
||
up of more abstract neuronal components. GENESIS has provided
|
||
the basis for laboratory courses in neural simulation at both
|
||
Caltech and the Marine Biological Laboratory in Woods Hole, MA,
|
||
as well as several other institutions. Most current GENESIS
|
||
applications involve realistic simulations of biological neural
|
||
systems. Although the software can also model more abstract
|
||
networks, other simulators are more suitable for backpropagation
|
||
and similar connectionist modeling.
|
||
|
||
|
||
<label id="JavaBayes">
|
||
<tag/JavaBayes/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.cmu.edu/~javabayes/">
|
||
</itemize>
|
||
|
||
The JavaBayes system is a set of tools, containing a
|
||
graphical editor, a core inference engine and a parser.
|
||
JavaBayes can produce:
|
||
<itemize>
|
||
<item> the marginal distribution for any variable in a network.
|
||
<item> the expectations for univariate functions (for example,
|
||
expected value for variables).
|
||
<item> configurations with maximum a posteriori probability.
|
||
<item> configurations with maximum a posteriori expectation for
|
||
univariate functions.
|
||
</itemize>
|
||
|
||
|
||
<label id="Jbpe">
|
||
<tag/Jbpe/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://cs.felk.cvut.cz/˜koutnij/studium/jbpe.html">
|
||
</itemize>
|
||
|
||
Jbpe is a back-propagation neural network editor/simulator.
|
||
|
||
Features
|
||
<itemize>
|
||
<item>Standart back-propagation networks creation.
|
||
<item>Saving network as a text file, which can be edited and loaded
|
||
back.
|
||
<item>Saving/loading binary file
|
||
<item>Learning from a text file (with structure specified below),
|
||
number of learning periods / desired network energy can be
|
||
specified as a criterion.
|
||
<item>Network recall
|
||
</itemize>
|
||
|
||
|
||
<label id="lens">
|
||
<tag/lens/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://tedlab.mit.edu/~dr/Lens/">
|
||
</itemize>
|
||
|
||
Lens is an efficient, yet flexible, neural network simulator that runs
|
||
on a variety of platforms, is able to handle large, complex
|
||
simulations, but is also reasonably easy for novices to operate. Lens
|
||
has three main design objectives:
|
||
|
||
<itemize>
|
||
<item>Speed: Both in performance and development time.
|
||
<item>Flexibility: Hundreds of scriptable functions and components.
|
||
<item>Customizability: Modular code to allow for easy extensions.
|
||
</itemize>
|
||
|
||
|
||
<label id="Nengo">
|
||
<tag/Nengo/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.nengo.ca/">
|
||
</itemize>
|
||
|
||
Nengo (Nengo Neural Simulator) is a graphical and scripting based
|
||
software package for simulating large-scale neural systems.
|
||
|
||
To use it, you define groups of neurons in terms of what they
|
||
represent, and then form connections between neural groups in terms of
|
||
what computation should be performed on those representations. Nengo
|
||
then uses the Neural Engineering Framework (NEF) to solve for the
|
||
appropriate synaptic connection weights to achieve this desired
|
||
computation. Nengo also supports various kinds of learning. Nengo helps
|
||
make detailed spiking neuron models that implement complex high-level
|
||
cognitive algorithms.
|
||
|
||
Among other things, Nengo has been used to implement motor control,
|
||
visual attention, serial recall, action selection, working memory,
|
||
attractor networks, inductive reasoning, path integration, and planning
|
||
with problem solving.
|
||
|
||
The Spaun <htmlurl url="http://models.nengo.ca/spaun"> neural simulator
|
||
is implemented in Nengo and its source is available as well.
|
||
|
||
|
||
<label id="NN Generator">
|
||
<tag/Neural Network Generator/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="ftp://ftp.idsia.ch/pub/rafal/">
|
||
</itemize>
|
||
|
||
The Neural Network Generator is a genetic algorithm for the
|
||
topological optimization of feedforward neural networks. It
|
||
implements the Semantic Changing Genetic Algorithm and the
|
||
Unit-Cluster Model. The Semantic Changing Genetic Algorithm is
|
||
an extended genetic algorithm that allows fast dynamic
|
||
adaptation of the genetic coding through population
|
||
analysis. The Unit-Cluster Model is an approach to the
|
||
construction of modular feedforward networks with a ''backbone''
|
||
structure.
|
||
|
||
NOTE: To compile this on Linux requires one change in the Makefiles.
|
||
You will need to change '-ltermlib' to '-ltermcap'.
|
||
|
||
|
||
<label id="NEURON">
|
||
<tag/NEURON/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.neuron.yale.edu/">
|
||
</itemize>
|
||
|
||
NEURON is an extensible nerve modeling and simulation
|
||
program. It allows you to create complex nerve models by
|
||
connecting multiple one-dimensional sections together to form
|
||
arbitrary cell morphologies, and allows you to insert multiple
|
||
membrane properties into these sections (including channels,
|
||
synapses, ionic concentrations, and counters). The interface was
|
||
designed to present the neural modeler with a intuitive
|
||
environment and hide the details of the numerical methods used
|
||
in the simulation.
|
||
|
||
|
||
<label id="Neuroph">
|
||
<tag/Neuroph/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://neuroph.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Neuroph is lightweight Java neural network framework to develop common
|
||
neural network architectures. It contains well designed, open source
|
||
Java library with small number of basic classes which correspond to
|
||
basic NN concepts. Also has nice GUI neural network editor to quickly
|
||
create Java neural network components.
|
||
|
||
|
||
<label id="PDP++">
|
||
<tag/PDP++/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://archive.cnbc.cmu.edu/Resources/PDP++/PDP++.html">
|
||
<item>FTP mirror (US): <htmlurl
|
||
url="ftp://grey.colorado.edu/pub/oreilly/pdp++/">
|
||
</itemize>
|
||
|
||
NOTE: Renamed to <ref id="Emergent">
|
||
|
||
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.
|
||
|
||
|
||
<label id="RNS">
|
||
<tag/RNS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/neural/systems/rns/">
|
||
</itemize>
|
||
|
||
RNS (Recurrent Network Simulator) is a simulator for recurrent
|
||
neural networks. Regular neural networks are also supported. The
|
||
program uses a derivative of the back-propagation algorithm, but
|
||
also includes other (not that well tested) algorithms.
|
||
|
||
Features include
|
||
<itemize>
|
||
<item>freely choosable connections, no restrictions besides memory
|
||
or CPU constraints
|
||
<item>delayed links for recurrent networks
|
||
<item>fixed values or thresholds can be specified for weights
|
||
<item>(recurrent) back-propagation, Hebb, differential Hebb,
|
||
simulated annealing and more
|
||
<item>patterns can be specified with bits, floats, characters,
|
||
numbers, and random bit patterns with Hamming distances can
|
||
be chosen for you
|
||
<item>user definable error functions
|
||
<item>output results can be used without modification as input
|
||
</itemize>
|
||
|
||
|
||
<label id="Python Smantic Nets">
|
||
<tag/Semantic Networks in Python/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://strout.net/info/coding/python/ai/index.html">
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item><bf>Entity</bf>: This class represents a noun; it is
|
||
something which can be related to other things, and about
|
||
which you can store facts.
|
||
<item><bf>Relation</bf>: 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).
|
||
<item><bf>Fact</bf>: A Fact is an assertion that a relationship
|
||
exists between two entities.
|
||
</itemize>
|
||
<p>
|
||
|
||
With these three object types, you can very quickly define knowledge
|
||
about a set of objects, and query them for logical conclusions.
|
||
|
||
|
||
<label id="Simbrain">
|
||
<tag/Simbrain/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.simbrain.net/">
|
||
</itemize>
|
||
|
||
SIMBRAIN is a free tool for building, running, and analyzing
|
||
neural-networks (computer simulations of brain circuitry). Simbrain
|
||
aims to be as visual and easy-to-use as possible. Unique features of
|
||
Simbrain include its integrated "world components" and its ability to
|
||
represent a network's state space. Simbrain is written in Java.
|
||
|
||
|
||
<label id="SNNS">
|
||
<tag/SNNS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www-ra.informatik.uni-tuebingen.de/SNNS/">
|
||
</itemize>
|
||
|
||
Stuttgart Neural Net Simulator. The simulator kernel is written in C and
|
||
quite 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.
|
||
|
||
|
||
<label id="TOOLDIAG">
|
||
<tag/TOOLDIAG/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.inf.ufes.br/˜thomas/home/soft.html">
|
||
<item>Alt site: <htmlurl
|
||
url="http://www.cs.cmu.edu/afs/cs/project/ai-repository/ai/areas/neural/systems/tooldiag/0.html">
|
||
</itemize>
|
||
|
||
TOOLDIAG is a collection of methods for statistical pattern
|
||
recognition. The main area of application is classification. The
|
||
application area is limited to multidimensional continuous
|
||
features, without any missing values. No symbolic features
|
||
(attributes) are allowed. The program in implemented in the 'C'
|
||
programming language and was tested in several computing
|
||
environments.
|
||
|
||
|
||
<label id="XNBC">
|
||
<tag/XNBC/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.b3e.jussieu.fr/xnbc/">
|
||
</itemize>
|
||
|
||
XNBC v8 is a simulation tool for the neuroscientists interested in
|
||
simulating biological neural networks using a user friendly tool.
|
||
|
||
XNBC is a software package for simulating biological neural networks.
|
||
|
||
Four neuron models are available, three phenomenologic models (xnbc,
|
||
leaky integrator and conditional burster) and an ion-conductance based
|
||
model. Inputs to the simulated neurons can be provided by experimental
|
||
data stored in files, allowing the creation of `hybrid'' networks.
|
||
|
||
|
||
</descrip>
|
||
|
||
<sect>Evolutionary Computing
|
||
<label id="Evolutionary Computing">
|
||
<p>
|
||
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
|
||
<it>evolve</it> toward a certain goal. This goal can be
|
||
anything from solving some engineering problem to winning a
|
||
game.
|
||
|
||
|
||
<sect1>EC class/code libraries
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
<label id="ANNEvolve">
|
||
<tag/ANNEvolve/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://annevolve.sourceforge.net/"
|
||
name="annevolve.sourceforge.net">
|
||
</itemize>
|
||
|
||
A collection of programs using evolved artificial neural networks to
|
||
solve a series of problems. The long term goal of the project is to
|
||
advance our level of understanding about simulated evolution as a means
|
||
to configure and optimize Artificial Neural Nets (ANNs). The medium
|
||
term goal is to apply our methods to a series of interesting problems
|
||
such as sail boat piloting and playing the game NIM.
|
||
|
||
A secondary goal is educational in nature. We attempt to write our
|
||
software with ample explanation, not just for the user, but for the
|
||
engineer/programmer/scientist who wants to understand the innermost
|
||
detail. All of the source code is freely available to anyone to use
|
||
without restriction.
|
||
|
||
All of the ANNEvolve software is implemented in C and Python.
|
||
|
||
|
||
<label id="EAP">
|
||
<tag/EAP/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://code.google.com/p/deap/">
|
||
</itemize>
|
||
|
||
EAP has been built using the Python and UNIX programming philosophies
|
||
in order to provide a transparent, simple and coherent environment for
|
||
implementing your favourite evolutionary algorithms. EAP is very easy
|
||
to use even for those who do not know much about the Python programming
|
||
language. EAP uses the object oriented paradigm that is provided by
|
||
Python in order to make development simple and beautiful. It also
|
||
contains a 15 illustrative and diversified examples, to help newcomers
|
||
to ramp up very quickly in using this environment.
|
||
|
||
It includes Genetic Algorithms using any imaginable representation,
|
||
Genetic Programming with strongly and loosely typed trees in addition
|
||
to automatically defined functions, Evolution Strategies (including
|
||
Covariance Matrix Adaptation), multiobjective optimization techniques
|
||
(NSGA-II and SPEA2), easy parallelization of algorithms and much more
|
||
like milestones, genealogy, etc.
|
||
|
||
|
||
<label id="daga">
|
||
<tag/daga/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://garage.cps.msu.edu/software/daga3.2/"
|
||
name="garage.cps.msu.edu/software/daga3.2/">
|
||
</itemize>
|
||
|
||
|
||
daga is an experimental release of a 2-level genetic algorithm
|
||
compatible with the GALOPPS GA software. It is a meta-GA which
|
||
dynamically evolves a population of GAs to solve a problem presented to
|
||
the lower-level GAs. When multiple GAs (with different operators,
|
||
parameter settings, etc.) are simultaneously applied to the same
|
||
problem, the ones showing better performance have a higher probability
|
||
of surviving and "breeding" to the next macro-generation (i.e.,
|
||
spawning new "daughter"-GAs with characteristics inherited from the
|
||
parental GA or GAs. In this way, we try to encourage good
|
||
problem-solving strategies to spread to the whole population of GAs.
|
||
|
||
|
||
<label id="DEAP">
|
||
<tag/DEAP/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://deap.googlecode.com">
|
||
</itemize>
|
||
|
||
DEAP is intended to be an easy to use distributed evolutionary
|
||
algorithm library in the Python language. Its two main components are
|
||
modular and can be used separately. The first module is a Distributed
|
||
Task Manager (DTM), which is intended to run on cluster of computers
|
||
using TCP or a MPI connection. The second part is the Evolutionary
|
||
Algorithms in Python (EAP) framework. EAP is the evolutionary core of
|
||
DEAP, it provides data structures, methods and tools to design any kind
|
||
of evolutionary algorithm. It works in perfect harmony with DTM,
|
||
allowing easy parallelization of any demanding evolutionary task.
|
||
|
||
|
||
<label id="dgpf">
|
||
<tag/dgpf/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://dgpf.sourceforge.net/"
|
||
name="dgpf.sourceforge.net">
|
||
</itemize>
|
||
|
||
The Distributed Genetic Programming Framework (DGPF) is a scalable Java
|
||
environment for heuristic, simulation-based search algorithms of any
|
||
kind and Genetic Algorithms in special. We use the broad foundation of
|
||
a search algorithms layer to provide a Genetic Programming system which
|
||
is able to create Turing-complete code.
|
||
|
||
It's under the LGPL license. It allows you to use heuristic searches
|
||
like GA and randomized Hill Climbing for any problem space you like to
|
||
with just minimal programming effort. Also, you may distribute all
|
||
these searches over a network, using the client/server, the
|
||
peer-to-peer, or even a client/server+ peer-to-peer hybrid distribution
|
||
scheme. You also can construct heterogeneous search algorithms where GA
|
||
cooperates with Hill Climbing without changing any code.
|
||
|
||
|
||
<label id="Ease">
|
||
<tag/Ease/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.sprave.com/Ease/Ease.html"
|
||
name="www.sprave.com/Ease/Ease.html">
|
||
</itemize>
|
||
|
||
Ease - Evolutionary Algorithms Scripting Evironment - is an extension
|
||
to the Tcl scripting language, providing commands to create, modify,
|
||
and evaluate populations of individuals represented by real number
|
||
vectors and/or bit strings.
|
||
|
||
|
||
<label id="EO">
|
||
<tag/EO/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://eodev.sourceforge.net/"
|
||
name="eodev.sourceforge.net">
|
||
</itemize>
|
||
|
||
EO is a templates-based, ANSI-C++ compliant evolutionary
|
||
computation library. It contains classes for any kind of
|
||
evolutionary computation (specially genetic algorithms) you might
|
||
come up to. It is component-based, so that if you don't find the
|
||
class you need in it, it is very easy to subclass existing
|
||
abstract or concrete class.
|
||
|
||
|
||
<label id="Evocosm">
|
||
<tag/Evocosm/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.coyotegulch.com/products/libevocosm/">
|
||
</itemize>
|
||
|
||
Evocosm is a set of classes that abstract the fundamental components of
|
||
an evolutionary algorithm. See the site for details, but here is a
|
||
simple list of the provided classes; Random Numbers, OpenMP,
|
||
Floating-Point Chromosomes, Roulettte Wheels, Organisms, Fitness
|
||
Landscapes, Evocosms, Fitness Scaling, Migration, Selecting Survivors,
|
||
Reproduction, Mutation Operations.
|
||
|
||
|
||
<label id="evolver">
|
||
<tag/evolver/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="https://launchpad.net/evolver">
|
||
</itemize>
|
||
|
||
A Python library for creating and working with genetic algorithms and
|
||
genetic (evolved) programs. Allows one to do Python-based evolutionary
|
||
programming; string-based as well as source code tree node
|
||
optimization/search solution discovery.
|
||
|
||
|
||
<label id="Fortran GA">
|
||
<tag/FORTRAN GA/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://cuaerospace.com/carroll/ga.html"
|
||
name="cuaerospace.com/carroll/ga.html">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="FREVO">
|
||
<tag/FREVO/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://frevo.sourceforge.net/">
|
||
</itemize>
|
||
|
||
FREVO is an open-source framework developed in Java to help engineers
|
||
and scientists in evolutionary design or optimization tasks. The major
|
||
feature of FREVO is the componentwise decomposition and separation of
|
||
the key building blocks for each optimization tasks. We identify these
|
||
as the problem definition, solution representation and the optimization
|
||
method. This structure enables the components to be designed separately
|
||
allowing the user to easily swap and evaluate different configurations
|
||
and methods or to connect an external simulation tool.
|
||
|
||
|
||
<label id="GALib">
|
||
<tag/GAlib: Matthew's Genetic Algorithms Library/
|
||
<itemize>
|
||
<item>Web Site: <htmlurl
|
||
url="http://lancet.mit.edu/ga/">
|
||
<item>Download: <htmlurl
|
||
url="http://lancet.mit.edu/ga/dist/">
|
||
<item>Register GAlib at: <htmlurl
|
||
url="http://lancet.mit.edu/ga/Register.html">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
|
||
<label id="GALOPPS">
|
||
<tag/GALOPPS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://garage.cse.msu.edu/software/galopps/">
|
||
<item>FTP site: <htmlurl
|
||
url="ftp://garage.cse.msu.edu/pub/GA/galopps/">
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item> (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.
|
||
<item> 5 selection methods: roulette wheel, stochastic remainder
|
||
sampling, tournament selection, stochastic universal sampling,
|
||
linear-ranking-then-SUS.
|
||
<item> 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.
|
||
<item> Binary or non-binary alphabetic fields on value-based
|
||
chromosomes, including different user-definable field sizes.
|
||
<item> 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.
|
||
<item> 4 crossovers for order-based reps: PMX, order-based, uniform
|
||
order-based, and cycle.
|
||
<item> 4 mutations: fast bitwise, multiple-field, swap and random
|
||
sublist scramble.
|
||
<item> Fitness scaling: linear scaling, Boltzmann scaling, sigma
|
||
truncation, window scaling, ranking.
|
||
<item><bf>Plus</bf> a whole lot more....
|
||
</itemize>
|
||
|
||
|
||
<label id="GAS">
|
||
<tag/GAS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://starship.python.net/crew/gandalf/">
|
||
</itemize>
|
||
|
||
GAS means "Genetic Algorithms Stuff".
|
||
GAS is freeware.
|
||
|
||
Purpose of GAS is to explore and exploit artificial evolutions.
|
||
Primary implementation language of GAS is Python. The GAS
|
||
software package is meant to be a Python framework for applying
|
||
genetic algorithms. It contains an example application where it
|
||
is tried to breed Python program strings. This special problem
|
||
falls into the category of Genetic Programming (GP), and/or
|
||
Automatic Programming. Nevertheless, GAS tries to be useful for
|
||
other applications of Genetic Algorithms as well.
|
||
|
||
|
||
<label id="GAUL">
|
||
<tag/GAUL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://gaul.sourceforge.net/">
|
||
<item>SF project site: <htmlurl
|
||
url="http://sourceforge.net/projects/gaul/">
|
||
</itemize>
|
||
|
||
The Genetic Algorithm Utility Library (GAUL) is a flexible programming
|
||
library designed to aid development of applications that require the
|
||
use of genetic algorithms. Features include:
|
||
|
||
<itemize>
|
||
<item>Darwinian, Lamarckian or Baldwinian evolutionary schemes.
|
||
<item>Both steady-state and generation-based GAs included.
|
||
<item>The island model of evolution is available.
|
||
<item>Chromosome datatype agnostic. A selection of common chromosome
|
||
types are built-in.
|
||
<item>Allows user-defined crossover, mutation, selection, adaptation
|
||
and replacement operators.
|
||
<item>Support for multiple, simultaneously evolved,populations.
|
||
<item>Choice of high-level or low-level interface functions.
|
||
<item>Additional, non-GA, optimisation algorithms are built-in for
|
||
local optimisation or comparative purposes.
|
||
<item>Trivial to extend using external code via the built-in code
|
||
hooks.
|
||
<item>May be driven by, or extended by, powerful S-Lang scripts.
|
||
<item>Support for multiprocessor calculations.
|
||
<item>Written using highly portable C code.
|
||
</itemize>
|
||
|
||
|
||
<label id="GECO">
|
||
<tag/GECO/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="http://common-lisp.net/project/geco/">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
<label id="GenePool">
|
||
<tag/GenePool/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.rubinsteyn.com/genepool/">
|
||
</itemize>
|
||
|
||
GenePool is a framework for writing evolutionary optimization
|
||
algorithms in OCaml. This library is not a complete solution but rather
|
||
is a generic skeleton which takes care of the plumbing and nuisances of
|
||
optimization. You provide GenePool with functions that give meaning to
|
||
fitness and reproduction and after a specified number of generation,
|
||
GenePool returns an array of the best "genomes" it evolved.
|
||
|
||
|
||
<label id="Genetic">
|
||
<tag/Genetic/
|
||
<itemize>
|
||
<item>Web site: ???
|
||
<item>You can get it from the debian repository:
|
||
<htmlurl
|
||
url="http://packages.qa.debian.org/g/genetic.html">
|
||
</itemize>
|
||
|
||
This is a package for genetic algorythms and AI in Python.
|
||
|
||
Genetic can typically solve ANY problem that consists to minimize a
|
||
function.
|
||
|
||
It also includes several demos / examples, like the TSP (traveling
|
||
saleman problem).
|
||
|
||
|
||
<label id="GPdata">
|
||
<tag/GPdata/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="ftp://ftp.cs.bham.ac.uk/pub/authors/W.B.Langdon/gp-code/">
|
||
</itemize>
|
||
|
||
GPdata-3.0.tar.gz (C++) contains a version of Andy Singleton's
|
||
GP-Quick version 2.1 which has been extensively altered to support:
|
||
<itemize>
|
||
<item>Indexed memory operation (cf. teller)
|
||
<item>multi tree programs
|
||
<item>Adfs
|
||
<item>parameter changes without recompilation
|
||
<item>populations partitioned into demes
|
||
<item>(A version of) pareto fitness
|
||
</itemize>
|
||
This ftp site also contains a small C++ program (ntrees.cc) to
|
||
calculate the number of different there are of a given length and
|
||
given function and terminal set.
|
||
|
||
|
||
<label id="Java GP - gpjpp">
|
||
<tag/gpjpp Genetic Programming in Java/
|
||
<itemize>
|
||
<item>The code can be found in the tarball linked from
|
||
"GP and Othello Java code and READMEs" on this page: <htmlurl
|
||
url="http://www1.cs.columbia.edu/~evs/ml/hw4.html">
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item>graphic output of expression trees
|
||
<item>efficient diversity checking
|
||
<item>Koza's greedy over-selection option for large populations
|
||
<item>extensible GPRun class that encapsulates most details of a
|
||
genetic programming test
|
||
<item>more robust and efficient streaming code, with automatic
|
||
checkpoint and restart built into the GPRun class
|
||
<item>an explicit complexity limit that can be set on each GP
|
||
<item>additional configuration variables to allow more testing
|
||
without recompilation
|
||
<item>support for automatically defined functions (ADFs)
|
||
<item>tournament and fitness proportionate selection
|
||
<item>demetic grouping
|
||
<item>optional steady state population
|
||
<item>subtree crossover
|
||
<item>swap and shrink mutation
|
||
</itemize>
|
||
|
||
|
||
<label id="jaga">
|
||
<tag/jaga/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://cs.felk.cvut.cz/˜koutnij/studium/jaga/jaga.html"
|
||
name="cs.felk.cvut.cz/˜koutnij/studium/jaga/jaga.html">
|
||
</itemize>
|
||
|
||
Simple genetic algorithm package written in Java.
|
||
|
||
|
||
<label id="JGAP">
|
||
<tag/JGAP/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://jgap.sourceforge.net/">
|
||
</itemize>
|
||
|
||
JGAP (pronounced "jay-gap") is a Genetic Algorithms and Genetic
|
||
Programming component provided as a Java framework. It provides basic
|
||
genetic mechanisms that can be easily used to apply evolutionary
|
||
principles to problem solutions.
|
||
|
||
JGAP was designed to be very easy to use "out of the box", while also
|
||
designed to be highly modular so that more adventurous users can easily
|
||
plug-in custom genetic operators and other sub-components.
|
||
|
||
|
||
<label id="lil-gp">
|
||
<tag/lil-gp/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://garage.cse.msu.edu/software/lil-gp/">
|
||
</itemize>
|
||
|
||
<tag/patched lil-gp */
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://cs.gmu.edu/˜sean/research/lil-gp-patch/">
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item> Generic 'C' program that runs on UNIX workstations
|
||
<item> 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).
|
||
<item> lil-gp manipulates trees of function pointers which are
|
||
allocated in single, large memory blocks for speed and to
|
||
avoid swapping.
|
||
</itemize>
|
||
* The patched lil-gp kernel is strongly-typed, with modifications on
|
||
multithreading, coevolution, and other tweaks and features.
|
||
|
||
|
||
<label id="Lithos">
|
||
<tag/Lithos/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.esatclear.ie/˜rwallace/lithos.html"
|
||
name="www.esatclear.ie/˜rwallace/lithos.html">
|
||
</itemize>
|
||
|
||
Lithos is a stack based evolutionary computation system. Unlike most EC
|
||
systems, its representation language is computationally complete, while
|
||
also being faster and more compact than the S-expressions used in
|
||
genetic programming. The version presented here applies the system to
|
||
the game of Go, but can be changed to other problems by simply plugging
|
||
in a different evaluation function. ANSI C source code is provided.
|
||
|
||
|
||
<label id="Open BEAGLE">
|
||
<tag/Open BEAGLE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://beagle.gel.ulaval.ca/"
|
||
name="beagle.gel.ulaval.ca">
|
||
</itemize>
|
||
|
||
Open BEAGLE is a C++ evolutionary computation framework. It provides a
|
||
high-level software environment to do any kind of evolutionary
|
||
computation, with support for tree-based genetic programming, bit
|
||
string and real-valued genetic algorithms, evolution strategy,
|
||
co-evolution, and evolutionary multi-objective optimization.
|
||
|
||
|
||
<label id="PGAPack">
|
||
<tag/PGAPack/ Parallel Genetic Algorithm Library
|
||
<itemize>
|
||
<item>FTP site: <htmlurl url="ftp://ftp.mcs.anl.gov/pub/pgapack/">
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item>Callable from Fortran or C.
|
||
<item>Runs on uniprocessors, parallel computers, and workstation networks.
|
||
<item>Binary-, integer-, real-, and character-valued native data types.
|
||
<item>Full extensibility to support custom operators and new data types.
|
||
<item>Easy-to-use interface for novice and application users.
|
||
<item>Multiple levels of access for expert users.
|
||
<item>Parameterized population replacement.
|
||
<item>Multiple crossover, mutation, and selection operators.
|
||
<item>Easy integration of hill-climbing heuristics.
|
||
<item>Extensive debugging facilities.
|
||
<item>Large set of example problems.
|
||
<item>Detailed users guide.
|
||
</itemize>
|
||
|
||
|
||
<label id="PIPE">
|
||
<tag/PIPE/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="ftp://ftp.idsia.ch/pub/rafal/"
|
||
name="ftp.idsia.ch/pub/rafal">
|
||
</itemize>
|
||
|
||
Probabilistic Incremental Program Evolution (PIPE) is a novel
|
||
technique for automatic program synthesis. The software is written in C.
|
||
It ...
|
||
|
||
<itemize>
|
||
<item>is easy to install (comes with an automatic installation tool).
|
||
<item>is easy to use: setting up PIPE_V1.0 for different
|
||
problems requires a minimal amount of programming. User-written,
|
||
application-independent program parts can easily be reused.
|
||
<item>is efficient: PIPE_V1.0 has been tuned to speed up
|
||
performance.
|
||
<item>is portable: comes with source code (optimized for SunOS
|
||
5.5.1).
|
||
<item>is extensively documented(!) and contains three example
|
||
applications.
|
||
<item>supports statistical evaluations: it facilitates running
|
||
multiple experiments and collecting results in output files.
|
||
<item>includes testing tool for testing generalization of evolved
|
||
programs.
|
||
<item>supports floating point and integer arithmetic.
|
||
<item>has extensive output features.
|
||
<item>For lil-gp users: Problems set up for lil-gp 1.0 can be
|
||
easily ported to PIPE_v1.0. The testing tool can also be
|
||
used to process programs evolved by lil-gp 1.0.
|
||
</itemize>
|
||
|
||
|
||
<label id="plop">
|
||
<tag/plop/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://code.google.com/p/plop/">
|
||
</itemize>
|
||
|
||
A Common Lisp framework for experimenting with meta-optimizing semantic
|
||
evolutionary search (<htmlurl url="http://metacog.org/doc.html"
|
||
name="MOSES">) and related approaches to learning with probability
|
||
distributions over program spaces based on:
|
||
|
||
<itemize>
|
||
<item>reduction to normal form
|
||
<item>representation-building
|
||
<item>deme (sub-population) management
|
||
<item>probabilistic model-building (aka estimation-of-distribution algorithms)
|
||
</itemize>
|
||
|
||
|
||
<label id="Pyevolve">
|
||
<tag/Pyevolve/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://pyevolve.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Pyevolve was developed to be a complete genetic algorithm framework,
|
||
the main objectives of Pyevolve are:
|
||
|
||
<itemize>
|
||
<item>written in pure python, to maximize the cross-platform issue;
|
||
<item>easy to use API, the API must be easy for end-user;
|
||
<item>see the evolution, the user can and must see and interact with
|
||
the evolution statistics, graphs and etc;
|
||
<item>extensible, the API must be extensible, the user can create new
|
||
representations, genetic operators like crossover, mutation and etc;
|
||
<item>fast, the design must be optimized for performance;
|
||
<item>common features, the framework must implement the most common
|
||
features: selectors like roulette wheel, tournament, ranking, uniform.
|
||
Scaling schemes like linear scaling, etc;
|
||
<item>default parameters, we must have default operators, settings,
|
||
etc in all options;
|
||
<item>open-source, the source is for everyone, not for only one.
|
||
</itemize>
|
||
|
||
|
||
<label id="pygp">
|
||
<tag/pygp/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/pygp/files/">
|
||
</itemize>
|
||
|
||
Your basic genetic algorithm package for python.
|
||
|
||
|
||
<label id="tinygp">
|
||
<tag/tinygp/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.laserpirate.com/as3tinygp/">
|
||
</itemize>
|
||
|
||
Small genetic programming library in C++ and ActionScript 3 (Javascript
|
||
engine embedded in Flash) with flash demos.
|
||
|
||
This GP library uses the standard Koza expression tree program
|
||
representation. It uses the 'grow' algorithm to generate random
|
||
expressions. Mutation is performed by selecting a random subexpression
|
||
in an expression tree, and replacing it with a new random expression
|
||
(which satisfies the maximum tree depth constraint). Crossover (mating)
|
||
between two expressions is performed by selecting a random
|
||
subexpression in each parent, then exchanging them (although it only
|
||
makes on child, not two).
|
||
|
||
In addition to the core code for creating, mutating, mating and
|
||
evaluating expressions, the library includes a steady-state genetic
|
||
algorithm with tournament selection, and a worst-out, elitist
|
||
replacement policy (i.e. when a new child is created, it replaces the
|
||
worse member of the population, only if it is better).
|
||
|
||
|
||
<label id="txevolver">
|
||
<tag/txevolver/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="https://launchpad.net/txevolver">
|
||
</itemize>
|
||
|
||
A Twisted-based set of libraries for performing calculations of genetic
|
||
algorithms as well as genetic programs in an asynchronous, distributed
|
||
manner.
|
||
|
||
|
||
</descrip>
|
||
|
||
|
||
<sect1>EC software kits/applications
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
|
||
<label id="ADATE">
|
||
<tag/ADATE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www-ia.hiof.no/˜rolando/adate_intro.html"
|
||
name="www-ia.hiof.no/˜rolando/adate_intro.html">
|
||
</itemize>
|
||
|
||
ADATE (Automatic Design of Algorithms Through Evolution) 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.
|
||
|
||
|
||
|
||
<label id="esep-xesep">
|
||
<tag/esep & xesep/
|
||
<itemize>
|
||
<item>Web site(esep): <htmlurl
|
||
url="http://www.iit.edu/˜elrad/esep.html"
|
||
name="www.iit.edu/˜elrad/esep.html">
|
||
<item>Web site(xesep): <htmlurl
|
||
url="http://www.iit.edu/˜elrad/xesep.html"
|
||
name="www.iit.edu/˜elrad/xesep.html">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
<label id="Corewars">
|
||
<tag/Corewars/
|
||
<itemize>
|
||
<item>SourceForge site: <htmlurl
|
||
url="http://sourceforge.net/projects/corewars/">
|
||
</itemize>
|
||
|
||
Corewars is a game which simulates a virtual machine with a number of
|
||
programs. Each program tries to crash the others. The program that
|
||
lasts the longest time wins. A number of sample programs are provided
|
||
and new programs can be written by the player. Screenshots are
|
||
available at the Corewars homepage.
|
||
|
||
|
||
<label id="JCASim">
|
||
<tag/JCASim/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.jweimar.de/jcasim/">
|
||
</itemize>
|
||
|
||
JCASim is a general-purpose system for simulating cellular automata in
|
||
Java. It includes a stand-alone application and an applet for web
|
||
presentations. The cellular automata can be specified in Java, in CDL,
|
||
or using an interactive dialogue. The system supports many different
|
||
lattice geometries (1-D, 2-D square, hexagonal, triangular, 3-D),
|
||
neighborhoods, boundary conditions, and can display the cells using
|
||
colors, text, or icons.
|
||
|
||
|
||
<label id="JGProg">
|
||
<tag/JGProg/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://jgprog.sourceforge.net/"
|
||
name="jgprog.sourceforge.net">
|
||
</itemize>
|
||
|
||
Genetic Programming (JGProg) is an open-source Java implementation of
|
||
a strongly-typed Genetic Programming experimentation platform. Two
|
||
example "worlds" are provided, in which a population evolves and
|
||
solves the problem.
|
||
|
||
|
||
</descrip>
|
||
|
||
|
||
|
||
|
||
<sect>Alife & Complex Systems
|
||
<label id="Alife & Complex Systems">
|
||
<p>
|
||
|
||
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 <it>emergent</it> behavior of
|
||
<it>complex adaptive systems</it>. 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. Complex Systems
|
||
(abbreviated CS) are very similar to alife in the way the are approached,
|
||
just more general in definition (ie. alife is a type of complex system).
|
||
Usually complex system software takes the form of a simulator.
|
||
|
||
|
||
<sect1>Alife & CS class/code libraries
|
||
<p>
|
||
|
||
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.
|
||
|
||
|
||
<descrip>
|
||
|
||
|
||
<label id="AgentFarms">
|
||
<tag/AgentFarms/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.agentfarms.net">
|
||
</itemize>
|
||
|
||
Agent Farms is a system for modelling and simulation of complex,
|
||
multi-agent based systems. The system can be used for:
|
||
<itemize>
|
||
<item>Creating models of multi-agent systems
|
||
<item>Interactive and distributed simulation
|
||
<item>Observation and visualisation of the simulation
|
||
<item>Population modification and migration
|
||
</itemize>
|
||
|
||
|
||
<label id="Biome">
|
||
<tag/Biome/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/biome/">
|
||
</itemize>
|
||
|
||
Biome is a C++ library aimed at individual-based/agent-based
|
||
simulations. It is somewhat similar to Swarm, EcoSim or Simex but tries
|
||
to be more efficient and less monolithic without compromising object-
|
||
oriented design. Currently there is an event based scheduling system, a
|
||
C++ified Mersenne-Twister RNG, several general analysis classes, some
|
||
Qt-based GUI classes, a very basic persistence/database framework (used
|
||
also for parameter storage) and many other small useful things.
|
||
|
||
|
||
<label id="CAGE">
|
||
<tag/CAGE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.alcyone.com/software/cage/">
|
||
</itemize>
|
||
|
||
CAGE is a fairy generic and complete cellular automaton simulation
|
||
engine in Python. It supports both 1D and 2D automata, a variety of
|
||
prepackaged rules, and the concept of "agents" which can move about
|
||
independently on the map for implementing agent behavior.
|
||
|
||
|
||
<label id="Cellular">
|
||
<tag/Cellular/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://zhar.net/howto/homeless/cellular/">
|
||
</itemize>
|
||
|
||
The Cellular automata programming system consists of a compiler for the
|
||
Cellang cellular automata programming language, along with the
|
||
corresponding documentation, viewer, and various tools. 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:
|
||
|
||
<itemize>
|
||
<item>any number of dimensions;
|
||
<item>compile time specification of each dimensions size;
|
||
cell neighborhoods of any size (though bounded at compile time)
|
||
and shape;
|
||
<item>positional and time dependent neighborhoods;
|
||
<item>associating multiple values (fields), including arrays,
|
||
with each cell;
|
||
<item>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
|
||
<item>local interactions only, since it is impossible to
|
||
construct automata that contain any global control or
|
||
references to global variables.
|
||
</itemize>
|
||
|
||
|
||
<label id="Integrating Modelling Toolkit">
|
||
<tag/Integrating Modelling Toolkit/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/imt/"
|
||
name="sourceforge.net/projects/imt/">
|
||
</itemize>
|
||
|
||
The Integrating Modelling Toolkit (IMT) is a generic, comprehensive,
|
||
and extensible set of abstractions allowing definition and use of
|
||
interoperable model components. Modellers create an IMT "world" made
|
||
of IMT "agents" that will perform each a particular phase of a
|
||
modelling task. The core set of IMT agents can describe generic,
|
||
modular, distributed model components, either native to the IMT or
|
||
integrating existing simulation toolkits, specialized for tasks that
|
||
range from simple calculation of functions in an interpreted language
|
||
to spatially explicit simulation, model optimization, GIS analysis,
|
||
visualization and advanced statistical analysis. IMT agents are
|
||
designed to easily "glue" together in higher-level simulations
|
||
integrating different modelling paradigms and toolkits. The IMT can be
|
||
easily extended by users and developers through a convenient plug-in
|
||
mechanism
|
||
|
||
|
||
<label id="MAML">
|
||
<tag/MAML/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.maml.hu/">
|
||
</itemize>
|
||
|
||
The current version of MAML is basically an extension to Objective-C
|
||
(using the Swarm libraries). It consists of a couple of
|
||
'macro-keywords' that define the general structure of a simulation. The
|
||
remaining must be filled with pure swarm-code. A MAML-to-Swarm (named
|
||
xmc) compiler is also being developed which compiles the source code
|
||
into a swarm application.
|
||
|
||
|
||
<label id="MASON">
|
||
<tag/MASON/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://cs.gmu.edu/~eclab/projects/mason/">
|
||
</itemize>
|
||
|
||
MASON Stands for Multi-Agent Simulator Of Neighborhoods... or
|
||
Networks... or something...
|
||
|
||
MASON is a fast discrete-event multi-agent simulation library core in
|
||
Java, designed to be the foundation for large custom-purpose Java
|
||
simulations, and also to provide more than enough functionality for
|
||
many lightweight simulation needs. MASON contains both a model library
|
||
and an optional suite of visualization tools in 2D and 3D.
|
||
|
||
|
||
<label id="SimWorld">
|
||
<tag/SimWorld/
|
||
<itemize>
|
||
<item>Web site: http://www.nd.edu/~airolab/simworld/
|
||
<item>New Web site?: http://hrilab.tufts.edu/
|
||
</itemize>
|
||
|
||
SimWorld is a free artificial life simulation (based on the free
|
||
<ref id="SimAgent"> toolkit developed by Aaron Sloman), which provides
|
||
functionality for running different interacting agents and objects in a
|
||
simulated, continuous environment. The agents are controlled by rules
|
||
written in the powerful rule interpreter. New behaviors of agents can
|
||
be defined without any programming knowledge.
|
||
|
||
|
||
<label id="Swarm">
|
||
<tag/Swarm/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.swarm.org/wiki/Swarm_main_page"
|
||
name="www.swarm.org/wiki/Swarm_main_page">
|
||
<item>FTP site: <htmlurl
|
||
url="http://ftp.swarm.org/pub/swarm/"
|
||
name="ftp.swarm.org/pub/swarm/">
|
||
</itemize>
|
||
|
||
|
||
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.
|
||
|
||
|
||
</descrip>
|
||
|
||
|
||
|
||
<sect1>Alife & CS software kits, applications, etc.
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
|
||
<label id="Achilles">
|
||
<tag/Achilles/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://achilles.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Achilles is an evolution simulation based on Larry Yaeger's PolyWorld.
|
||
It uses Hebbian neural networks, and an extremely simplified physical
|
||
model that allows virtual organisms to interact freely in a simulated
|
||
environment.
|
||
|
||
|
||
<label id="Avida">
|
||
<tag/Avida/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://avida.devosoft.org/">
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/avida/">
|
||
</itemize>
|
||
|
||
The computer program Avida is an auto-adaptive genetic system designed
|
||
primarily for use as a platform in Artificial Life research. The Avida
|
||
system is based on concepts similar to those employed by the Tierra
|
||
program, that is to say it is a population of self-reproducing strings
|
||
with a Turing-complete genetic basis subjected to Poisson-random
|
||
mutations. The population adapts to the combination of an intrinsic
|
||
fitness landscape (self-reproduction) and an externally imposed
|
||
(extrinsic) fitness function provided by the researcher. By studying
|
||
this system, one can examine evolutionary adaptation, general traits of
|
||
living systems (such as self-organization), and other issues pertaining
|
||
to theoretical or evolutionary biology and dynamic systems.
|
||
|
||
|
||
<label id="Biogenesis">
|
||
<tag/Biogenesis/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://biogenesis.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Biogenesis is an artificial life program that simulates the processes
|
||
involved in the evolution of organisms. It shows colored segment based
|
||
organisms that mutate and evolve in a 2D environment. Biogenesis is
|
||
based on Primordial Life.
|
||
|
||
|
||
<label id="breve">
|
||
<tag/breve/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.spiderland.org/breve/"
|
||
name="www.spiderland.org/breve/">
|
||
</itemize>
|
||
|
||
Breve is a free software package which makes it easy to build 3D
|
||
simulations of decentralized systems and artificial life. Users define
|
||
the behaviors of agents in a 3D world and observe how they interact.
|
||
Breve includes physical simulation and collision detection so you can
|
||
simulate realistic creatures, and an OpenGL display engine so you can
|
||
visualize your simulated worlds.
|
||
|
||
|
||
<label id="BugsX">
|
||
<tag/BugsX/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="https://github.com/porridge/bugsx">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Creatures Docking Station">
|
||
<tag/Creatures Docking Station/
|
||
<itemize>
|
||
<item>Linux info: <htmlurl
|
||
url="http://www.creaturesdockingstation.com/">
|
||
</itemize>
|
||
|
||
This is a free version of the Creatures3 ALife game. It has fewer
|
||
species and a small 'space-station' world, but can connect to other
|
||
worlds over the internet and (if you have the windows version of the
|
||
game) can connect to your C3 world. The game itself revolves around
|
||
breeding and training the alife creatures, 'Norns'. Its strikes a
|
||
pretty nice balance between fun and science, or so I'm told.
|
||
|
||
(summary written by Steve Grand included below)
|
||
|
||
The eponymous creatures in this computer game are called Norns, and the
|
||
world's population of them at one stage hovered around the five million
|
||
mark, making them more common than many familiar natural species. Each
|
||
norn is composed of thousands of tiny simulated biological components,
|
||
such as neurons, biochemicals, chemoreceptors, chemoemitters and genes.
|
||
The norns' genes dictate how these components are assembled to make
|
||
complete organisms, and the creatures' behaviour then emerges from the
|
||
interactions of those parts, rather than being explicitly 'programmed
|
||
in'.
|
||
|
||
The norns are capable of learning about their environment, either by
|
||
being shown things by their owners or through learning by their own
|
||
mistakes. They must learn for themselves how to find food and how to
|
||
interact with the many objects in their environment. They can interact
|
||
with their owners, using simple language, and also with each other.
|
||
They can form relationships and produce offspring, which inherit their
|
||
neural and biochemical structure from their parents and are capable of
|
||
open-ended evolution over time. They can fall prey to a variety of
|
||
diseases (as well as genetic defects) and can be treated with
|
||
appropriate medicines.
|
||
|
||
|
||
<label id="Critterding">
|
||
<tag/Critterding/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://critterding.sourceforge.net/">
|
||
<item>Web site (telepathic-critterdrug): <htmlurl
|
||
url="http://m-net.arbornet.org/~flamoot/telepathic-critterdrug.html">
|
||
</itemize>
|
||
|
||
Critterding is a "Petri dish" universe in 3D that demonstrates evolving
|
||
artificial life. Critters start out with completely random brains and
|
||
bodies, but will automatically start evolving into something with much
|
||
better survival skills. The lifeforms are placed in an artificial
|
||
environment where there neural net 'brains' can evolve.
|
||
|
||
Telepathic-critterdrug is a fork of Critterding introducing a
|
||
communications medium (called a retina) and psychoactive substances
|
||
that effect this retina.
|
||
|
||
|
||
<label id="dblife-dblifelib">
|
||
<tag/dblife & dblifelib/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="http://ibiblio.org/pub/Linux/science/ai/life/"
|
||
name="ibiblio.org/pub/Linux/science/ai/life/">
|
||
</itemize>
|
||
|
||
<it>dblife:</it> 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.
|
||
|
||
<it>dblifelib:</it> 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.
|
||
|
||
|
||
<label id="Drone">
|
||
<tag/Drone/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cscs.umich.edu/Software/Drone/"
|
||
name="www.cscs.umich.edu/Software/Drone/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="EcoLab">
|
||
<tag/EcoLab/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://ecolab.sourceforge.net/">
|
||
</itemize>
|
||
|
||
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++.
|
||
|
||
|
||
<label id="Framsticks">
|
||
<tag/Framsticks/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.frams.alife.pl/">
|
||
</itemize>
|
||
|
||
Framsticks is a three-dimensional life simulation project. Both
|
||
mechanical structures ("bodies") and control systems ("brains") of
|
||
creatures are modeled. It is possible to design various kinds of
|
||
experiments, including simple optimization (by evolutionary
|
||
algorithms), co-evolution, open-ended and spontaneous evolution,
|
||
distinct gene pools and populations, diverse genotype/phenotype
|
||
mappings, and species/ecosystems modeling.
|
||
|
||
|
||
<label id="Fluidiom">
|
||
<tag/Fluidiom/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ostatic.com/fluidiom">
|
||
</itemize>
|
||
|
||
Evolutionary based alife platform. Has a game like feel which makes it
|
||
fun while still allowing for some interesting experimentation.
|
||
|
||
It takes a minimalist approach to spatial structure to make a body,
|
||
adds articulation in the form of muscles, and then lets evolution take
|
||
over to see if these bodies can learn to walk, run, crawl, or slither
|
||
from one place to the other.
|
||
|
||
|
||
<label id="Game Of Life">
|
||
<tag/Game Of Life (GOL)/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="http://ibiblio.org/pub/Linux/science/ai/life/"
|
||
name="ibiblio.org/pub/Linux/science/ai/life/">
|
||
</itemize>
|
||
|
||
GOL is a simulator for conway's game of life (a simple cellular
|
||
automata), and other simple rule sets. The emphasis here is on
|
||
speed and scale, in other words you can setup large and fast
|
||
simulations.
|
||
|
||
|
||
<label id="gant">
|
||
<tag/gant/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://gant.sourceforge.net/"
|
||
name="gant.sourceforge.net">
|
||
</itemize>
|
||
|
||
This project is an ANSI C++ implementation of the Generalized Langton
|
||
Ant, which lives on a torus.
|
||
|
||
|
||
<label id="gLife">
|
||
<tag/gLife/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://glife.sourceforge.net/"
|
||
name="glife.sourceforge.net">
|
||
<item>SourceForge site: <htmlurl
|
||
url="http://sourceforge.net/projects/glife/"
|
||
name="sourceforge.net/projects/glife/">
|
||
</itemize>
|
||
|
||
This program is similiar to "Conway's Game of Life" but yet it is very
|
||
different. It takes "Conway's Game of Life" and applies it to a society
|
||
(human society). This means there is a very different (and much larger)
|
||
rule set than in the original game. Things need to be taken into account
|
||
such as the terrain, age, sex, culture, movement, etc
|
||
|
||
|
||
<label id="Golly">
|
||
<tag/Golly/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://golly.sourceforge.net/"
|
||
name="golly.sourceforge.net">
|
||
</itemize>
|
||
|
||
An open source, cross-platform implementation of John Conway's Game of
|
||
Life with an unbounded universe and capable of running patterns faster
|
||
and further than ever before. It has many features such as;
|
||
|
||
<itemize>
|
||
<item>Reads RLE, Life 1.05/1.06, and macrocell formats.
|
||
<item>Supports Wolfram's 1D rules.
|
||
<item>Can paste in patterns from the clipboard.
|
||
<item>Scriptable via Python.
|
||
</itemize>
|
||
|
||
|
||
<label id="Langton's Ant">
|
||
<tag/Langton's Ant/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://theory.org/software/ant/">
|
||
</itemize>
|
||
|
||
Langton's Ant is an example of a finite-state cellular automata. The
|
||
ant (or ants) start out on a grid. Each cell is either black or white.
|
||
If the ant is on a black square, it turns right 90 and moves forward
|
||
one unit. If the ant is on a white square, it turns left 90 and moves
|
||
forward one unit. And when the ant leaves a square, it inverts the
|
||
color. The neat thing about Langton's Ant is that no matter what
|
||
pattern field you start it out on, it eventually builds a "road," which
|
||
is a series of 117 steps that repeat indefinitely, each time leaving
|
||
the ant displaced one pixel vertically and horizontally.
|
||
|
||
|
||
<label id="LEE">
|
||
<tag/LEE/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.informatics.indiana.edu/fil/LEE/"
|
||
name="www.informatics.indiana.edu/fil/LEE/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="MATREM">
|
||
<tag/MATREM/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.romansland.nl/matrem/">
|
||
</itemize>
|
||
|
||
Matrem is a computer program that simulates life. It belongs to the
|
||
emerging science of "artificial life", which studies evolution and
|
||
complex systems in general by simulation. Matrem is also a game, where
|
||
players compete to create the fittest life form. Their efforts are the
|
||
driving force behind the program.
|
||
|
||
|
||
<label id="Nanopond">
|
||
<tag/Nanopond/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://adam.ierymenko.name/nanopond.shtml">
|
||
</itemize>
|
||
|
||
Nanopond is a "corewar style" evolvable instruction set based virtual
|
||
machine written in C. It is similar in design to Tierra and Avida but
|
||
considerably smaller and simpler. Version 1.0 weights in at only 840
|
||
lines of C code, the majority of which are comments! It is very highly
|
||
optimized and supports simple color visualization using the SDL (Simple
|
||
Directmedia Layer) library.
|
||
|
||
More information can be learned by reading the Nanopond source code,
|
||
which is very well commented.
|
||
|
||
|
||
<label id="Noble Ape">
|
||
<tag/Noble Ape/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.nobleape.com/sim/"
|
||
name="www.nobleape.com/sim/">
|
||
</itemize>
|
||
|
||
The Noble Ape Simulation has been developed (as the Nervana Simulation)
|
||
since 1996. The aim of the simulation is to create a detailed
|
||
biological environment and a cognitive simulation. The Simulation is
|
||
intended as a palette for open source development. It provides a stable
|
||
means of simulating large scale environments and cognitive processes.
|
||
|
||
It features a number of autonomous simulation components including a
|
||
landscape simulation, biological simulation, weather simulation,
|
||
sentient creature (Noble Ape) simulation and a simple intelligent-agent
|
||
scripting language (ApeScript).
|
||
|
||
The code is currently (2007) used by Apple Inc and by INTEL for
|
||
processor optimization and performance tuning. Apple includes it with
|
||
their CHUD performance and debugging developer tool set.
|
||
|
||
<label id="Polyworld">
|
||
<tag/Polyworld/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/polyworld">
|
||
</itemize>
|
||
|
||
PolyWorld is a computational ecology that I developed to explore issues
|
||
in Artificial Life. Simulated organisms reproduce sexually, fight and
|
||
kill and eat each other, eat the food that grows throughout the world,
|
||
and either develop successful strategies for survival or die. An
|
||
organism's entire behavioral suite (move, turn, attack, eat, mate,
|
||
light) is controlled by its neural network "brain". Each brain's
|
||
architecture--it's neural wiring diagram--is determined from its
|
||
genetic code, in terms of number, size, and composition of neural
|
||
clusters (excitatory and inhibitory neurons) and the types of
|
||
connections between those clusters (connection density and topological
|
||
mapping). Synaptic efficacy is modulated via Hebbian learning, so, in
|
||
principle, the organisms have the ability to learn during the course of
|
||
their lifetimes. The organisms perceive their world through a sense of
|
||
vision, provided by a computer graphic rendering of the world from each
|
||
organism's point of view. The organisms' physiologies are also encoded
|
||
genetically, so both brain and body, and thus all components of
|
||
behavior, evolve over multiple generations. A variety of "species",
|
||
with varying individual and group survival strategies have emerged in
|
||
various simulations, displaying such complex ethological behaviors as
|
||
swarming/flocking, foraging, and attack avoidance.
|
||
|
||
|
||
<label id="POSES++">
|
||
<tag/POSES++/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.gpc.de/e_poses.html">
|
||
</itemize>
|
||
|
||
The POSES++ software tool supports the development and
|
||
simulation of models. Regarding the simulation technique models
|
||
are suitable reproductions of real or planned systems for their
|
||
simulative investigation.
|
||
<p>
|
||
|
||
In all industrial sectors or branches POSES++ can model and
|
||
simulate any arbitrary system which is based on a discrete and
|
||
discontinuous behaviour. Also continuous systems can mostly be
|
||
handled like discrete systems e.g., by quantity discretion and
|
||
batch processing.
|
||
|
||
|
||
<label id="Tierra">
|
||
<tag/Tierra/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://life.ou.edu/tierra/">
|
||
</itemize>
|
||
|
||
|
||
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 evolve-able. 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.
|
||
|
||
|
||
<label id="Trend">
|
||
<tag/Trend/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.complex.iastate.edu/download/Trend/"
|
||
name="www.complex.iastate.edu/download/Trend/">
|
||
</itemize>
|
||
|
||
Trend is a general purpose cellular automata simulation environment
|
||
with an integrated high level language compiler, a beautiful graphical
|
||
user interface, and a fast, three stage cached simulation engine. This
|
||
is the simulation system that was used to discover the first emergent
|
||
self-replicating cellular automata rule set, and the first problem
|
||
solving self-replication loop.
|
||
|
||
Since its simulator is very flexible with regard to cellular space
|
||
sizes, cell structures, neighborhood structures and cellular automata
|
||
rules, Trend can simulate almost all one or two-dimensional cellular
|
||
automata models. It also has a smart backtracking feature which
|
||
simplifies rule set development a lot by allowing users to go back to a
|
||
previous stage of simulation! With other advanced features, Trend is
|
||
probably the most easy to use 2-dimensional cellular automata
|
||
simulator.
|
||
|
||
Also available is jTrend. A Java version of Trend.
|
||
|
||
|
||
<label id="XLIFE">
|
||
<tag/XLIFE/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="http://linux.maruhn.com/sec/xlife.html">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Xtoys">
|
||
<tag/Xtoys/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://thy.phy.bnl.gov/www/xtoys/xtoys.html">
|
||
</itemize>
|
||
|
||
xtoys contains a set of cellular automata simulators for X windows.
|
||
Programs included are:
|
||
<itemize>
|
||
<item> xising --- a two dimensional Ising model simulator,
|
||
<item> xpotts --- the two dimensional Potts model,
|
||
<item> xautomalab --- a totalistic cellular automaton simulator,
|
||
<item> xsand --- for the Bak, Tang, Wiesenfeld sandpile model,
|
||
<item> xwaves --- demonstrates three different wave equations,
|
||
<item> schrodinger --- play with the Scrodinger equation in an
|
||
adjustable potential.
|
||
</itemize>
|
||
|
||
</descrip>
|
||
|
||
<sect>Agents & Robotics
|
||
<label id="Agents & Robotics">
|
||
<label id="Agents">
|
||
<p>
|
||
|
||
Software brains for computers that do stuff. Everythin from fun and
|
||
games to data mining to physical robotics. This is a great hobbiest
|
||
area of AI with many areas of interest to pursue. I've broken it down
|
||
loosely into 2 sections. AI for purely software based agents and that
|
||
for embodied agents (even if only simulated).
|
||
|
||
|
||
<sect1>Software Agents
|
||
<label id="Software Agents">
|
||
<p>
|
||
|
||
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.
|
||
|
||
<descrip>
|
||
|
||
<label id="2APL">
|
||
<tag/2APL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://apapl.sourceforge.net/">
|
||
</itemize>
|
||
|
||
2APL (pronounced as double-a-p-l) is an agent-oriented programming
|
||
language that facilitates the implementation of multi-agent systems. At
|
||
the multi-agent level, it provides programming constructs to specify a
|
||
multi-agent system in terms of a set of individual agents, a set of
|
||
environments in which they can perform actions, and the access relation
|
||
between the individual agents and the environments. At the individual
|
||
agent level, it provides programming constructs to implement cognitive
|
||
agents based on the BDI architecture.
|
||
|
||
|
||
<label id="3APL">
|
||
<tag/3APL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.uu.nl/3apl/">
|
||
<item>Wikipedia entry: <htmlurl
|
||
url="http://en.wikipedia.org/wiki/3APL">
|
||
<item>Mobile version: <htmlurl
|
||
url="http://www.cs.uu.nl/3apl-m/">
|
||
</itemize>
|
||
|
||
3APL is a programming language for implementing cognitive agents. It
|
||
provides programming constructs for implementing agents' beliefs,
|
||
goals, basic capabilities (such as belief updates, external actions, or
|
||
communication actions) and a set of practical reasoning rules through
|
||
which agents' goals can be updated or revised. The 3APL programs are
|
||
executed on the 3APL platform. Each 3APL program is executed by means
|
||
of an interpreter that deliberates on the cognitive attitudes of that
|
||
agent.
|
||
|
||
|
||
<label id="Agent">
|
||
<tag/Agent/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="http://www.cpan.org/modules/by-category/23_Miscellaneous_Modules/Agent/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="agentTool">
|
||
<tag/agentTool/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://agenttool.cis.ksu.edu/">
|
||
</itemize>
|
||
|
||
agentTool is a Eclipse-based graphical development environment to help
|
||
users analyze, design, and implement multiagent systems. It is
|
||
designed to support the highly tailorable Organization-based Multiagent
|
||
Systems Engineering (O-MaSE) methodology. agentTool currently supports
|
||
all O-MaSE models including the Goal Model, Agent Model, Role Model,
|
||
Organization Model, Protocol Model, Plan Model, Capability-Action
|
||
Model, Domain Model, and Policy Model.
|
||
|
||
|
||
<label id="Aglets">
|
||
<tag/Aglets Workbench/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.trl.ibm.com/aglets/index_e.htm">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="AJA">
|
||
<tag/AJA/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://home.arcor.de/michal.badonsky/AJA/">
|
||
</itemize>
|
||
|
||
AJA (Adaptable Java Agents) consists of two programming languages.
|
||
HADL (Higher Agent Definition Language) is a higher-level language used
|
||
for the description of the main agent parts. Java+ is the lower-level
|
||
language used for the programming of the agent parts defined in HADL.
|
||
It is actually Java enriched with the constructs for accessing
|
||
higher-level agent parts defined in HADL.
|
||
|
||
|
||
<label id="A.L.I.C.E.">
|
||
<tag/A.L.I.C.E./
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.alicebot.org/">
|
||
<item>Other AIML implementations:
|
||
<htmlurl url="http://pyaiml.sourceforge.net/">
|
||
</itemize>
|
||
|
||
The ALICE software implements AIML (Artificial Intelligence Markup
|
||
Language), a non-standard evolving markup language for creating chat
|
||
robots. The primary design feature of AIML is minimalism. Compared with
|
||
other chat robot languages, AIML is perhaps the simplest. The pattern
|
||
matching language is very simple, for example permitting only one
|
||
wild-card ('*') match character per pattern. AIML is an XML language,
|
||
implying that it obeys certain grammatical meta-rules. The choice of
|
||
XML syntax permits integration with other tools such as XML editors.
|
||
Another motivation for XML is its familiar look and feel, especially to
|
||
people with HTML experience.
|
||
|
||
|
||
<label id="APRIL">
|
||
<tag/APRIL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/networkagent/">
|
||
</itemize>
|
||
|
||
APRIL is a symbolic programming language that is designed for writing
|
||
mobile, distributed and agent-based systems especially in an Internet
|
||
environment. It has advanced features such as a macro sub-language,
|
||
asynchronous message sending and receiving, code mobility, pattern
|
||
matching, higher-order functions and strong typing. The language is
|
||
compiled to byte-code which is then interpreted by the APRIL
|
||
runtime-engine. APRIL now requires the InterAgent Communications Model
|
||
(ICM) to be installed before it can be installed. [Ed. ICM can be found
|
||
at the same web site]
|
||
|
||
|
||
<label id="Ara">
|
||
<tag/Ara/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://wwwagss.informatik.uni-kl.de/Projekte/Ara/index_e.html">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Bee-gent">
|
||
<tag/Bee-gent/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.toshiba.co.jp/rdc/beegent/download/download.htm">
|
||
<item>FAQ: <htmlurl
|
||
url="http://www.toshiba.co.jp/rdc/beegent/faq/faq.htm">
|
||
</itemize>
|
||
|
||
Bee-gent is a new type of development framework in that it is a 100%
|
||
pure agent system. As opposed to other systems which make only some use
|
||
of agents, Bee-gent completely "Agentifies" the communication that
|
||
takes place between software applications. The applications become
|
||
agents, and all messages are carried by agents. Thus, Bee-gent allows
|
||
developers to build flexible open distributed systems that make optimal
|
||
use of existing applications.
|
||
|
||
|
||
<label id="Bond">
|
||
<tag/Bond/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://bond.cs.ucf.edu/">
|
||
</itemize>
|
||
|
||
Bond is a Java based distributed object system and agent framework. It
|
||
implements a message based middleware and associated services like
|
||
directory, persistence, monitoring and security. Bond allows to easily
|
||
build multi agent, distributed applications. Another application of
|
||
Bond will be a Virtual Laboratory supporting data annotation and
|
||
metacomputing.
|
||
|
||
|
||
<label id="Cougaar">
|
||
<tag/Cougaar/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cougaar.org/">
|
||
</itemize>
|
||
|
||
Cougaar is java-based architecture for the construction of large-scale
|
||
distributed agent-based applications. It is the product of a
|
||
multi-year DARPA research project into large scale agent systems and
|
||
includes not only the core architecture but also a variety of
|
||
demonstration, visualization and management components to simplify the
|
||
development of complex, distributed applications. [Yet another java
|
||
based agent system -- ed.]
|
||
|
||
|
||
<label id="D'Agent">
|
||
<tag/D'Agent (was AGENT TCL)/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://agent.cs.dartmouth.edu/software/agent2.0/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="DIET Agents">
|
||
<tag/DIET Agents/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://diet-agents.sourceforge.net">
|
||
</itemize>
|
||
|
||
DIET Agents is a lightweight, scalable and robust multi-agent platform
|
||
in Java. It is especially suitable for rapidly developing P2P prototype
|
||
applications and/or adaptive, distributed applications that use
|
||
bottom-up, nature-inspired techniques.
|
||
|
||
|
||
<label id="FishMarket">
|
||
<tag/FishMarket/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.iiia.csic.es/Projects/fishmarket/newindex.html">
|
||
</itemize>
|
||
|
||
FM - The FishMarket project conducted at the Artificial Intelligence
|
||
Research Institute (IIIA-CSIC) attempts to contribute in that direction
|
||
by developing FM, an agent-mediated electronic auction house which has
|
||
been evolved into a test-bed for electronic auction markets. The
|
||
framework, conceived and implemented as an extension of FM96.5 (a
|
||
Java-based version of the Fishmarket auction house), allows to define
|
||
trading scenarios based on fish market auctions (Dutch auctions). FM
|
||
provides the framework wherein agent designers can perform controlled
|
||
experimentation in such a way that a multitude of experimental market
|
||
scenarios--that we regard as tournament scenarios due to the
|
||
competitive nature of the domain-- of varying degrees of realism and
|
||
complexity can be specified, activated, and recorded; and trading
|
||
(buyer and seller) heterogeneous (human and software) agents compared,
|
||
tuned and evaluated.
|
||
|
||
|
||
<label id="Grasshopper">
|
||
<tag/Grasshopper/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.grasshopper.de/">
|
||
</itemize>
|
||
|
||
Another Java agent system. Full featured and actively developed.
|
||
Commercial, but free. Historically targeted at embedded systems.
|
||
|
||
|
||
<label id="Hive">
|
||
<tag/Hive/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://hive.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Hive is a Java software platform for creating distributed applications.
|
||
Using Hive, programmers can easily create systems that connect and use
|
||
data from all over the Internet. At its heart, Hive is an environment
|
||
for distributed agents to live, communicating and moving to fulfill
|
||
applications. We are trying to make the Internet alive.
|
||
|
||
|
||
<label id="ICM">
|
||
<tag/ICM/
|
||
<itemize>
|
||
<item>SourceForge site: <htmlurl
|
||
url="http://sourceforge.net/projects/networkagent/">
|
||
</itemize>
|
||
|
||
The Inter-Agent Communication Model (ICM) is a communication mechanism
|
||
that can be used for sending messages between agents in an asynchronous
|
||
fashion. Its intended application area is as a transportation mechanism
|
||
for agent communication languages (ACLs), such as KQML and FIPA's ACL.
|
||
|
||
|
||
<label id="Jacomma">
|
||
<tag/Jacomma/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://jacomma.sourceforge.net/">
|
||
<item>SourceForge site: <htmlurl
|
||
url="http://sourceforge.net/projects/jacomma/">
|
||
</itemize>
|
||
|
||
Jacomma is an agent development platform/framework for developing
|
||
distributed, mobile, and reactive information agents with heterogeneous
|
||
communication capabilities, in Java and JPython.
|
||
|
||
Jacomma provides a development framework and an execution environment,
|
||
which sits on top of the Inter-Agent Communication Model
|
||
infrastructure. The ICM defines a communication protocol, a store and
|
||
forward messaging architecture, and low level communication
|
||
infrastructure for message exchange. Communication is truly
|
||
asynchronous, based on TCP sockets.
|
||
|
||
ICM has an entry in this howto, or you can find it via a link off the
|
||
site.
|
||
|
||
|
||
<label id="Jade">
|
||
<tag/Jade/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://sharon.cselt.it/projects/jade/">
|
||
</itemize>
|
||
|
||
JADE (Java Agent DEvelopment Framework) is a software framework fully
|
||
implemented in Java language. It simplifies the implementation of
|
||
multi-agent systems through a middle-ware that claims to comply with
|
||
the FIPA specifications and through a set of tools that supports the
|
||
debugging and deployment phase. The agent platform can be distributed
|
||
across machines (which not even need to share the same OS) and the
|
||
configuration can be controlled via a remote GUI. The configuration can
|
||
be even changed at run-time by moving agents from one machine to
|
||
another one, as and when required.
|
||
|
||
|
||
<label id="JAM Agent">
|
||
<tag/JAM Agent/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.marcush.net/IRS/irs_downloads.html">
|
||
</itemize>
|
||
|
||
JAM supports both top-down, goal-based reasoning and bottom-up
|
||
data-driven reasoning. JAM selects goals and plans based on maximal
|
||
priority if metalevel reasoning is not used, or user-developed
|
||
metalevel reasoning plans if they exist. JAM's conceptualization of
|
||
goals and goal achievement is more classically defined (UMPRS is more
|
||
behavioral performance-based than truly goal-based) and makes the
|
||
distinction between plans to achieve goals and plans that simply encode
|
||
behaviors. Goal-types implemented include achievement (attain a
|
||
specified world state), maintenance (re-attain a specified world
|
||
state), and performance. Execution of multiple simultaneous goals are
|
||
supported, with suspension and resumption capabilities for each goal
|
||
(i.e., intention) thread. JAM plans have explicit precondition and
|
||
runtime attributes that restrict their applicability, a postcondition
|
||
attribute, and a plan attributes section for specifying
|
||
plan/domain-specific plan features. Available plan constructs include:
|
||
sequencing, iteration, subgoaling, atomic (i.e., non-interruptable)
|
||
plan segments, n-branch deterministic and non-deterministic conditional
|
||
execution, parallel execution of multiple plan segments, goal-based or
|
||
world state-based synchronization, an explicit failure-handling
|
||
section, and Java primitive function definition through building it
|
||
into JAM as well as the invocation of predefined (i.e., legacy) class
|
||
members via Java's reflection capabilities without having to build it
|
||
into JAM.
|
||
|
||
|
||
<label id="JASA">
|
||
<tag/JASA/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.csc.liv.ac.uk/~sphelps/jasa">
|
||
<item>Alt Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/jasa/">
|
||
</itemize>
|
||
|
||
JASA is a high performance auction simulator suitable for conducting
|
||
experiments in agent-based computational economics. It implements
|
||
various auction mechanisms, trading strategies and experiments
|
||
described in the computational economics literature, and as the
|
||
software matures we hope that it will become a repository for reference
|
||
implementations of commonly used mechanisms, strategies and learning
|
||
algorithms.
|
||
|
||
|
||
<label id="Jason">
|
||
<tag/Jason/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://jason.sourceforge.net/">
|
||
</itemize>
|
||
|
||
A Java-based interpreter for an extended version of AgentSpeak. Unlike
|
||
other BDI (Beliefs-Desires-Intentions) agent tools, Jason implements
|
||
the operational semantics of AgentSpeak, a BDI logic programming
|
||
language extensively discussed in the literature. It is available as
|
||
Open Source under GNU LGPL.
|
||
|
||
|
||
<label id="JATLite">
|
||
<tag/JATLite/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://java.stanford.edu/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="JATLiteBeans">
|
||
<tag/JATLiteBeans/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://waitaki.otago.ac.nz/JATLiteBean/">
|
||
</itemize>
|
||
|
||
<itemize>
|
||
|
||
<item>Improved, easier-to-use interface to JATLite features
|
||
including KQML message parsing, receiving, and sending.
|
||
|
||
<item>Extensible architecture for message handling and agent
|
||
"thread of control" management
|
||
|
||
<item>Useful functions for parsing of simple KQML message content
|
||
|
||
<item>JATLiteBean supports automatic advertising of agent
|
||
capabilities to facilitator agents
|
||
|
||
<item>Automatic, optional, handling of the "forward" performative
|
||
|
||
<item>Generic configuration file parser
|
||
|
||
<item>KQML syntax checker
|
||
|
||
</itemize>
|
||
|
||
|
||
<label id="Java Agent Template">
|
||
<tag/Java(tm) Agent Template/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www-cdr.stanford.edu/ABE/JavaAgent.html"
|
||
name="www-cdr.stanford.edu/ABE/JavaAgent.html">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="lyntin">
|
||
<tag/lyntin/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://lyntin.sourceforge.net/"
|
||
name="lyntin.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Lyntin is an extensible Mud client and framework for the creation of
|
||
autonomous agents, or bots, as well as mudding in general. Lyntin is
|
||
centered around Python, a dynamic, object-oriented, and fun programming
|
||
language and based on TinTin++ a lovely mud client.
|
||
|
||
|
||
<label id="Mole">
|
||
<tag/Mole/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://mole.informatik.uni-stuttgart.de/"
|
||
name="mole.informatik.uni-stuttgart.de/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Narval">
|
||
<tag/Narval/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.logilab.org/"
|
||
name="www.logilab.org">
|
||
</itemize>
|
||
|
||
Narval is the acronym of "Network Assistant Reasoning with a Validating
|
||
Agent Language". It is a personal network assistant based on artificial
|
||
intelligence and agent technologies. It executes recipes (sequences of
|
||
actions) to perform tasks. It is easy to specify a new action using XML
|
||
and to implement it using Python. Recipes can be built and debugged
|
||
using a graphical interface.
|
||
|
||
|
||
<label id="NeL">
|
||
<tag/NeL/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.nevrax.org/"
|
||
name="www.nevrax.org">
|
||
</itemize>
|
||
|
||
NeL is actually a game development library (for massive multi-player
|
||
games), but I'm including it here as it (will) include a fairly
|
||
sizable AI library. Here's a blurb from the whitepaper:
|
||
|
||
The purpose of the AI library is to provide a pragmatic approach to
|
||
creating a distributed agents platform. Its focus is agents; individual
|
||
entities that communicate regardless of location, using an
|
||
action-reaction model.
|
||
|
||
|
||
<label id="OAA">
|
||
<tag/OAA/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.ai.sri.com/˜oaa/"
|
||
name="www.ai.sri.com/˜oaa/">
|
||
</itemize>
|
||
|
||
The Open Agent Architecture is a framework in which a community of
|
||
software agents running on distributed machines can work together on
|
||
tasks assigned by human or non-human participants in the community.
|
||
Distributed cooperation and high-level communication are two ideas
|
||
central to the foundation of the OAA.
|
||
|
||
It defines an interagent communication language and supports multiple
|
||
platforms and programming languages.
|
||
|
||
|
||
<label id="OpenCV">
|
||
<tag/OpenCV/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://opencvlibrary.sourceforge.net/">
|
||
</itemize>
|
||
|
||
OpenCV (Open Source Computer Vision) is a library of programming
|
||
functions mainly aimed at real time computer vision.
|
||
|
||
Example applications of the OpenCV library are Human-Computer
|
||
Interaction (HCI); Object Identification, Segmentation and Recognition;
|
||
Face Recognition; Gesture Recognition; Motion Tracking, Ego Motion,
|
||
Motion Understanding; Structure From Motion (SFM); and Mobile Robotics.
|
||
|
||
|
||
<label id="OpenCog">
|
||
<tag/OpenCog/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.opencog.org/">
|
||
</itemize>
|
||
|
||
The Open Cognition Framework (OpenCog) is software for the
|
||
collaborative development of safe and beneficial Artificial General
|
||
Intelligence.
|
||
|
||
OpenCog provides research scientists and software developers with a
|
||
common platform to build and share artificial intelligence programs.
|
||
The framework includes:
|
||
|
||
<itemize>
|
||
<item>a flexible and highly optimized in-memory database for
|
||
knowledge representation,
|
||
<item>a plug-in architecture for cognitive algorithms and a cognitive
|
||
process scheduler,
|
||
<item>a built-in LISP-like programming language, and
|
||
<item>other components to support artificial intelligence research
|
||
and development.
|
||
</itemize>
|
||
|
||
|
||
<label id="OpenSteer">
|
||
<tag/OpenSteer/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://opensteer.sourceforge.net/"
|
||
name="opensteer.sourceforge.net">
|
||
</itemize>
|
||
|
||
OpenSteer is a C++ library to help build steering behaviors for
|
||
autonomous characters in games and animation. OpenSteer provides an app
|
||
which displays predefined demos of steering behaviors. You can
|
||
prototype, visualize and debug your own as a plug-in.
|
||
|
||
|
||
<label id="ORTS">
|
||
<tag/ORTS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="https://skatgame.net/mburo/orts/">
|
||
</itemize>
|
||
|
||
ORTS is a programming environment for studying real-time AI problems
|
||
such as pathfinding, dealing with imperfect information, scheduling,
|
||
and planning in the domain of RTS games. These games are fast-paced and
|
||
very popular. Furthermore, the current state of RTS game AI is bleak
|
||
which is mainly caused by the lack of planning and learning - areas in
|
||
which humans are currently much better than machines. Therefore, RTS
|
||
games make an ideal test-bed for real-time AI research. Unfortunately,
|
||
commercial RTS games are closed software which prevents researchers
|
||
from connecting remote AI modules to them. Furthermore, commercial RTS
|
||
games are based on peer-to-peer technology - which in a nutshell runs
|
||
the entire simulation on all player machines and just hides part of the
|
||
game state from the players. By tampering with the client software it
|
||
is possible to reveal the entire game state and thereby gain an unfair
|
||
advantage. We feel that this is unacceptable for playing games on the
|
||
internet. We therefore started the ORTS project to create a free
|
||
software system that lets people and machines play fair RTS games. The
|
||
communication protocol is public and all source code and artwork is
|
||
freely available. Users can connect whatever client software they like.
|
||
This is made possible by a server/client architecture in which only the
|
||
currently visible parts of the game state are sent to the players. This
|
||
openness leads to new and interesting possibilities ranging from
|
||
on-line tournaments of autonomous AI players to gauge their playing
|
||
strength to hybrid systems in which human players use sophisticated
|
||
GUIs which allow them to delegate tasks to AI helper modules of
|
||
increasing performance.
|
||
|
||
|
||
<label id="Penguin!">
|
||
<tag/Penguin!/
|
||
<itemize>
|
||
<item>FTP site: <htmlurl
|
||
url="http://www.cpan.org/modules/by-category/23_Miscellaneous_Modules/Penguin/FSG/">
|
||
</itemize>
|
||
|
||
Penguin is a Perl 5 module. It provides you with a set of functions which
|
||
allow you to:
|
||
<itemize>
|
||
<item>send encrypted, digitally signed Perl code to a remote machine
|
||
to be executed.
|
||
<item>receive code and, depending on who signed it, execute it in an
|
||
arbitrarily secure, limited compartment.
|
||
</itemize>
|
||
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.
|
||
|
||
|
||
<label id="Ps-i">
|
||
<tag/Ps-i/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ps-i.sourceforge.net/"
|
||
name="ps-i.sourceforge.net">
|
||
</itemize>
|
||
|
||
Ps-i is an environment for running agent-based simulations. It is
|
||
cross-platform, with binaries available for Win32. Features include:
|
||
|
||
<itemize>
|
||
<item>declarative language for model specification</item>
|
||
<item>industry standard Tcl/Tk scripting
|
||
with built-in routine optimization, speculative evaluation
|
||
and xf86 JIT compiler users can create complex models without
|
||
sacrificing perfomance </item>
|
||
<item>user friendly interface </item>
|
||
<item>save and restore program runs </item>
|
||
<item>change model parameters on the fly </item>
|
||
<item>data visualization: field display with multiple agent shapes and
|
||
color, statistics window, agent viewer, routine browser and
|
||
highlight agents tool </item>
|
||
</itemize>
|
||
|
||
|
||
<label id="Pyro">
|
||
<tag/Pyro/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://pyrorobotics.org/"
|
||
name="http://pyrorobotics.org/">
|
||
</itemize>
|
||
|
||
Pyro is a library, environment, graphical user interface, and low-level
|
||
drivers to explore AI and robotics using the Python language. It works
|
||
with many real robotics platforms and simulators. Extensive algorithms
|
||
including behavior-based, vision (motion tracking, blobs, etc.),
|
||
learning (back-propagation, self-organizing maps, etc.), evolutionary,
|
||
and more.
|
||
|
||
|
||
<label id="Quackle">
|
||
<tag/Quackle/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.quackle.org/">
|
||
<item>Alt Web site: <htmlurl
|
||
url="http://web.mit.edu/jasonkb/www/quackle/">
|
||
<item>Alt Web site: <htmlurl
|
||
url="http://sourceforge.net/projects/quackle">
|
||
</itemize>
|
||
|
||
Quackle is a world-class crossword game artificial intelligence and
|
||
analysis tool. It includes a move generator, simulator, and Qt-based
|
||
user interface and can be used with any board layout, alphabet,
|
||
lexicon, and tile distribution.
|
||
|
||
|
||
<label id="Recast">
|
||
<tag/Recast/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://code.google.com/p/recastnavigation/">
|
||
</itemize>
|
||
|
||
Recast is state of the art navigation mesh construction toolset for
|
||
games.
|
||
|
||
<itemize>
|
||
<item>It is automatic, which means that you can throw any level
|
||
geometry at it and you will get robust mesh out
|
||
<item>It is fast which means swift turnaround times for level
|
||
designers
|
||
<item>It is open source so it comes with full source and you can
|
||
customize it to your hearts content.
|
||
</itemize>
|
||
|
||
The Library is free for commercial use and open source under the ZLib
|
||
License.
|
||
|
||
Recast is accompanied with Detour, path-finding and spatial reasoning
|
||
toolkit. You can use any navigation mesh with Detour, but of course the
|
||
data generated with Recast fits perfectly.
|
||
|
||
Detour offers simple static navigation mesh which is suitable for many
|
||
simple cases, as well as tiled navigation mesh which allows you to plug
|
||
in and out pieces of the mesh. The tiled mesh allows to create systems
|
||
where you stream new navigation data in and out as the player
|
||
progresses the level, or you may regenerate tiles as the world changes.
|
||
|
||
|
||
<label id="Remembrance Agents">
|
||
<tag/Remembrance Agents/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.remem.org/"
|
||
name="www.remem.org">
|
||
</itemize>
|
||
|
||
Remembrance Agents are a set of applications that watch over a user's
|
||
shoulder and suggest information relevant to the current situation.
|
||
While query-based memory aids help with direct recall, remembrance
|
||
agents are an augmented associative memory. For example, the
|
||
word-processor version of the RA continuously updates a list of
|
||
documents relevant to what's being typed or read in an emacs buffer.
|
||
These suggested documents can be any text files that might be relevant
|
||
to what you are currently writing or reading. They might be old emails
|
||
related to the mail you are currently reading, or abstracts from papers
|
||
and newspaper articles that discuss the topic of your writing.
|
||
|
||
|
||
<label id="SimAgent">
|
||
<tag/SimAgent/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.bham.ac.uk/research/projects/poplog/packages/simagent.html"
|
||
name="www.cs.bham.ac.uk/research/projects/poplog/packages/simagent.html">
|
||
</itemize>
|
||
|
||
The SimAgent toolkit provides a range of resources for research and
|
||
teaching related to the development of interacting agents in
|
||
environments of various degrees and kinds of complexity. It can be run
|
||
as a pure simulation tool, or installed in a robot with a sufficiently
|
||
powerful on-board computer, e.g. running linux. It was originally
|
||
developed to support exploratory research on human-like intelligent
|
||
agents, but has also been used for student projects developing a
|
||
variety of interactive games and simulations.
|
||
|
||
|
||
<label id="spyse">
|
||
<tag/spyse/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://spyse.sf.net/"
|
||
name="spyse.sf.net">
|
||
<item>Alt Web site: <htmlurl
|
||
url="http://zope.org/Members/drapmeyer/spyse"
|
||
name="zope.org/Members/drapmeyer/spyse">
|
||
</itemize>
|
||
|
||
spyse is a development framework and platform for building multi-agent
|
||
systems using the Python programming language. A multi-agent system
|
||
(MAS) combines concepts from distributed computing and artificial
|
||
intelligence. Agents are autonomously reasoning software entities that
|
||
can collaborate (or compete) in order to achieve a (common) goal. By
|
||
cooperating they create emergent behaviour in the system (distributed
|
||
artificial intelligence). The architecture of a MAS is specified in the
|
||
FIPA standard.
|
||
|
||
Spyse provides multiple means for reasoning (BDI logics, CLIPS expert
|
||
shell, etc.) and communicating locally and remotely.
|
||
|
||
Each agent has its own thread of control. Agents within and among
|
||
instances of the platform communicate by exchanging messages based on
|
||
ontologies. Spyse makes use of the Web Ontology Language (OWL) defined
|
||
for the Semantic Web.
|
||
|
||
|
||
<label id="TKQML">
|
||
<tag/TKQML/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.csee.umbc.edu/tkqml/"
|
||
name="www.csee.umbc.edu/tkqml/">
|
||
</itemize>
|
||
|
||
TKQML is a KQML application/addition to Tcl/Tk, which allows Tcl
|
||
based systems to communicate easily with a powerful agent
|
||
communication language.
|
||
|
||
|
||
<label id="Tocoma Project">
|
||
<tag/The Tocoma Project/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.tacoma.cs.uit.no/"
|
||
name="www.tacoma.cs.uit.no/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="UMPRS Agent">
|
||
<tag/UMPRS Agent/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.marcush.net/IRS/"
|
||
name="http://www.marcush.net/IRS/">
|
||
</itemize>
|
||
|
||
UMPRS supports top-down, goal-based reasoning and selects goals and
|
||
plans based on maximal priority. Execution of multiple simultaneous
|
||
goals are supported, with suspension and resumption capabilities for
|
||
each goal (i.e., intention) thread. UMPRS plans have an integrated
|
||
precondition/runtime attribute that constrain their applicability.
|
||
Available plan constructs include: sequencing, iteration, subgoaling,
|
||
atomic (i.e., non-interruptable) blocks, n-branch deterministic
|
||
conditional execution, explicit failure-handling section, and C++
|
||
primitive function definition.
|
||
|
||
|
||
<label id="WebMate">
|
||
<tag/WebMate/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.cs.cmu.edu/˜softagents/webmate/">
|
||
</itemize>
|
||
|
||
|
||
WebMate is a personal agent for World-Wide Web browsing and
|
||
searching. It accompanies you when you travel on the internet
|
||
and provides you what you want.
|
||
|
||
Features include:
|
||
<itemize>
|
||
|
||
<item>Searching enhancement, including parallel search, searching
|
||
keywords refinement using our relevant keywords extraction technology,
|
||
relevant feedback, etc.
|
||
|
||
<item>Browsing assistant, including learning your current interesting,
|
||
recommending you new URLs according to your profile and selected
|
||
resources, monitoring bookmarks of Netscape or IE, sending the current
|
||
browsing page to your friends, etc.
|
||
|
||
<item>Offline browsing, including downloading the following pages from
|
||
the current page for offline browsing.
|
||
|
||
<item>Filtering HTTP header, including recording http header and all
|
||
the transactions between your browser and WWW servers, etc.
|
||
|
||
<item>Checking the HTML page to find the errors or dead links, etc.
|
||
|
||
<item>Programming in Java, independent of operating system, runing in
|
||
multi-thread.
|
||
|
||
</itemize>
|
||
|
||
</descrip>
|
||
|
||
<sect1>Robotics and Simulators
|
||
|
||
<label id="Robotics and Simulators">
|
||
<p>
|
||
|
||
From fun battling robot games to full robot control systems. The idea is
|
||
physical agents in the real world, or at least their control programming.
|
||
|
||
<descrip>
|
||
|
||
<label id="BattleBots">
|
||
<tag/BattleBots/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.bluefire.nu/battlebots/"
|
||
name="www.bluefire.nu/battlebots/">
|
||
</itemize>
|
||
|
||
AI programming game where you design the bot by selecting hardware and
|
||
programming its CPU, then competing with other bots. Competitions can
|
||
have teams and special rules for a game.
|
||
|
||
The hardware for use in your bot includes weapons, engine, scanners,
|
||
CPU, etc. The programming lauguage is dependent on the CPU type and is
|
||
similar to an assembly language.
|
||
|
||
|
||
<label id="Cadaver">
|
||
<tag/Cadaver/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.erikyyy.de/cadaver/"
|
||
name="www.erikyyy.de/cadaver/">
|
||
</itemize>
|
||
|
||
Cadaver is a simulated world of cyborgs and nature in realtime. The
|
||
battlefield consists of forests, grain, water, grass, carcass (of
|
||
course) and lots of other things. The game server manages the game and
|
||
the rules. You start a server and connect some clients. The clients
|
||
communicate with the server using a very primitive protocol. They can
|
||
order cyborgs to harvest grain, attack enemies or cut forest. The game
|
||
is not intended to be played by humans! There is too much to control.
|
||
Only for die-hards: Just telnet to the server and you can enter
|
||
commands by hand. Instead the idea is that you write artificial
|
||
intelligence clients to beat the other artificial intelligences. You
|
||
can choose a language (and operating system) of your choice to do that
|
||
task. It is enough to write a program that communicates on standard
|
||
input and standard output channels. Then you can use programs like
|
||
"socket" to connect your clients to the server. It is NOT needed to
|
||
write TCP/IP code, although i did so :) The battle shall not be boring,
|
||
and so there is the so called spyboss client that displays the action
|
||
graphically on screen.
|
||
|
||
|
||
<label id="Carmen">
|
||
<tag/Carmen/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://carmen.sourceforge.net/">
|
||
</itemize>
|
||
|
||
CARMEN, the Carnegie Mellon Robot Navigation Toolkit. CARMEN is an
|
||
open-source collection of software for mobile robot control. CARMEN is
|
||
modular software designed to provide basic navigation primatives
|
||
including: base and sensor control, logging, obstacle avoidance,
|
||
localization, path planning, and mapping.
|
||
|
||
|
||
<label id="CLARAty">
|
||
<tag/CLARAty/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://claraty.jpl.nasa.gov/man/overview/">
|
||
</itemize>
|
||
|
||
CLARAty is an integrated framework for reusable robotic software. It
|
||
defines interfaces for common robotic functionality and integrates
|
||
multiple implementations of any given functionality. Examples of such
|
||
capabilities include pose estimation, navigation, locomotion and
|
||
planning. In addition to supporting multiple algorithms, it provides
|
||
adaptations to multiple robotic platforms.
|
||
|
||
This is a public release of the some of the code used in the Mars rover
|
||
projects at NASA. It is under a free for non-commercial use licence and
|
||
consists of large number of modules and algorithms along with extensive
|
||
documentation.
|
||
|
||
|
||
<label id="GNU Robots">
|
||
<tag/GNU Robots/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.gnu.org/software/robots/">
|
||
</itemize>
|
||
|
||
GNU Robots is a game/diversion where you construct a program for a
|
||
little robot, then watch him explore a world. The world is
|
||
filled with baddies that can hurt you, objects that you can bump into,
|
||
and food that you can eat. The goal of the game is to collect as
|
||
many prizes as possible before are killed by a baddie or you run out of
|
||
energy. Robots can be written in Guile scheme or using a GUI.
|
||
|
||
|
||
<label id="Infon Battle Arena">
|
||
<tag/Infon Battle Arena/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://infon.dividuum.de/">
|
||
<item>Web site: <htmlurl
|
||
url="https://github.com/dividuum/infon">
|
||
</itemize>
|
||
|
||
Infon Battle Arena is a networked multiplayer real-time programming
|
||
game featuring little creatures fighting for food. You upload your
|
||
Creature Code (written in Lua) to a game server using a telnet
|
||
Interface. The game server then runs your code. The graphical client
|
||
can be used to watch running games or replay recorded games.
|
||
|
||
|
||
<label id="Khepera Sim">
|
||
<tag/Khepera Simulator/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://diwww.epfl.ch/w3lami/team/michel/khep-sim/">
|
||
</itemize>
|
||
|
||
Khepera Simulator is a public domain software package written by
|
||
<htmlurl url="http://diwww.epfl.ch/w3lami/team/michel/" name="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.
|
||
|
||
|
||
<label id="MRPT">
|
||
<tag/MRPT/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://babel.isa.uma.es/mrpt/index.php/Main_Page">
|
||
</itemize>
|
||
|
||
The Mobile Robot Programming Toolkit (MRPT) is an extensive,
|
||
cross-platform, and open source C++ library aimed to help robotics
|
||
researchers to design and implement algorithms in the fields of
|
||
Simultaneous Localization and Mapping (SLAM), computer vision, and
|
||
motion planning (obstacle avoidance).
|
||
|
||
|
||
<label id="Nero">
|
||
<tag/Nero/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.nerogame.org/">
|
||
</itemize>
|
||
|
||
Neuro-Evolving Robotic Operatives, or NERO for short, is a unique
|
||
computer game that lets you play with adapting intelligent agents
|
||
hands-on. Evolve your own robot army by tuning their artificial brains
|
||
for challenging tasks, then pit them against your friends' teams in
|
||
online competitions!
|
||
|
||
The goals of the project are (1) to demonstrate the power of
|
||
state-of-the-art machine learning technology, (2) to create an engaging
|
||
game based on it, and (3) to provide a robust and challenging
|
||
development and benchmarking domain for AI researchers.
|
||
|
||
Closed source but free to download. They are working on OpenNERO which
|
||
will be open source and more intended as a research platform.
|
||
|
||
|
||
<label id="Orca">
|
||
<tag/Orca/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://orca-robotics.sourceforge.net/">
|
||
<item>Web site: <htmlurl
|
||
url="https://github.com/naderman/orca-robotics">
|
||
</itemize>
|
||
|
||
Orca is an open-source framework for developing component-based robotic
|
||
systems. It provides the means for defining and developing the
|
||
building-blocks which can be pieced together to form arbitrarily
|
||
complex robotic systems, from single vehicles to distributed sensor
|
||
networks.
|
||
|
||
|
||
<label id="Player">
|
||
<tag/Player/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://playerstage.sourceforge.net/">
|
||
<item>Player wiki: <htmlurl
|
||
url="http://playerstage.sourceforge.net/wiki/Player">
|
||
</itemize>
|
||
|
||
Player is a device server that provides a powerful, flexible interface
|
||
to a variety of sensors and actuators (e.g., robots). Because Player
|
||
uses a TCP socket-based client/server model, robot control programs can
|
||
be written in any programming language and can execute on any computer
|
||
with network connectivity to the robot. In addition, Player supports
|
||
multiple concurrent client connections to devices, creating new
|
||
possibilities for distributed and collaborative sensing and control.
|
||
|
||
|
||
<label id="RealTimeBattle">
|
||
<tag/RealTimeBattle/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://realtimebattle.sourceforge.net/">
|
||
</itemize>
|
||
|
||
RealTimeBattle is a programming game, in which robots controlled by
|
||
programs are fighting each other. The goal is to destroy the enemies,
|
||
using the radar to examine the environment and the cannon to shoot.
|
||
|
||
<itemize>
|
||
<item>Game progresses in real time, with the robot programs
|
||
running as child processes to RealTimeBattle.
|
||
<item>The robots communicate with the main program using the
|
||
standard input and output.
|
||
<item>Robots can be constructed in almost any programming language.
|
||
<item>Maximum number of robots can compete simultaneously.
|
||
<item>A simple messaging language is used for communication, which
|
||
makes it easy to start constructing robots.
|
||
<item>Robots behave like real physical object.
|
||
<item>You can create your own arenas.
|
||
<item>Highly configurable.
|
||
</itemize>
|
||
|
||
|
||
<label id="Robocode">
|
||
<tag/Robocode/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://robocode.sourceforge.net/">
|
||
</itemize>
|
||
|
||
A java based robot combat programming game. It provides a simple API
|
||
and class framework. It is designed as a means of learning Java and is
|
||
easy to start using while not constraining the programmer from more
|
||
advanced techniques. It has a built in security manager for running
|
||
other peoples robots in a safe way.
|
||
|
||
|
||
<label id="Robodeb">
|
||
<tag/Robodeb/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.transterpreter.org/robodeb/">
|
||
</itemize>
|
||
|
||
Robodeb is a complete robotics simulation environment for teaching
|
||
concurrency and parallelism. It provides a unique environment for
|
||
exploring concurrency and robotics. It provides a complete IDE for the
|
||
occam-pi programming language, and leverages the Transterpreter, our
|
||
portable and flexible runtime for the language. This combination is
|
||
critical, as it provides a principled interface to the Player/Stage
|
||
API, a set of widely used libraries for controlling the Pioneer3
|
||
robotics platform.
|
||
|
||
|
||
<label id="RobotFlow">
|
||
<tag/RobotFlow/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://robotflow.sourceforge.net/">
|
||
</itemize>
|
||
|
||
RobotFlow is a mobile robotics tookit based on the
|
||
<htmlurl url="http://flowdesigner.sourceforge.net" name="FlowDesigner">
|
||
project. FlowDesigner is a data-flow oriented architecture, similar to
|
||
Simulink (Matlab) or Labview that is free (LGPL) and versatile. The
|
||
visual programming interface provided in the FlowDesigner project will
|
||
help people to better visualize & understand what is really happening
|
||
in the robot's control loops, sensors, actuators, by using graphical
|
||
probes and debugging in real-time.
|
||
|
||
|
||
<label id="RoboTournament">
|
||
<tag/RoboTournament/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://robotournament.sourceforge.net/">
|
||
</itemize>
|
||
|
||
RoboTournament is a RoboRally inspired game where players program their
|
||
robots to vanquish their opponents. RoboTournament features: Multiple
|
||
Game Types: Death Match, Rally, and Capture The Flag. Multi-Player
|
||
through TCP/IP, Six weapons including BFG, Map Editor, and a wide
|
||
variety of board elements.
|
||
|
||
|
||
<label id="ROS">
|
||
<tag/ROS/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.ros.org/wiki/">
|
||
</itemize>
|
||
|
||
ROS is an operating system for your robot. It provides the services you
|
||
would expect from an operating system, including hardware abstraction,
|
||
low-level device control, implementation of commonly-used
|
||
functionality, message-passing between processes, and package
|
||
management. It also provides tools and libraries for obtaining,
|
||
building, writing, and running code across multiple computers.
|
||
|
||
|
||
<label id="Simbad">
|
||
<tag/Simbad/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://simbad.sourceforge.net/">
|
||
</itemize>
|
||
|
||
Simbad is a Java 3d robot simulator for scientific and educationnal
|
||
purposes. It is mainly dedicated to researchers/programmers who want
|
||
a simple basis for studying Situated Artificial Intelligence, Machine
|
||
Learning, and more generally AI algorithms, in the context of
|
||
Autonomous Robotics and Autonomous Agents. It is not intented to
|
||
provide a real world simulation and is kept voluntarily readable and
|
||
simple.
|
||
|
||
Simbad enables programmers to write their own robot controller, modify
|
||
the environment and use the available sensors. Don't think of it as a
|
||
finite product but merely as an opened framework to test your own
|
||
ideas.
|
||
|
||
|
||
<label id="SimRobot">
|
||
<tag/SimRobot/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.informatik.uni-bremen.de/simrobot/">
|
||
<item>FTP site: <htmlurl
|
||
url="ftp://ftp.uni-bremen.de/pub/ZKW/INFORM/simrobot/">
|
||
</itemize>
|
||
|
||
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.
|
||
<itemize>
|
||
<item>Simulation of robot kinematics
|
||
<item>Hierarchically built scene definition via a simple definition
|
||
language
|
||
<item>Various sensors built in: camera, facette eye, distance
|
||
measurement, light sensor, etc.
|
||
<item>Objects defined as polyeders
|
||
<item>Emitter abstractly defined; can be interpreted e.g. as
|
||
light or sound
|
||
<item>Camera images computed according to the raytracing or
|
||
Z-buffer algorithms known from computer graphics
|
||
<item>Specific sensor/motor software interface for communicating
|
||
with the simulation
|
||
<item>Texture mapping onto the object surfaces: bitmaps in various
|
||
formats
|
||
<item>Comprehensive visualization of the scene: wire frame w/o
|
||
hidden lines, sensor and actor values
|
||
<item>Interactive as well as batch driven control of the agents
|
||
and operation in the environment
|
||
<item>Collision detection
|
||
<item>Extendability with user defined object types
|
||
<item>Possible socket communication to e.g. the Khoros image
|
||
processing software
|
||
</itemize>
|
||
|
||
|
||
<label id="TclRobots">
|
||
<tag/TclRobots/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.nyx.net/˜tpoindex/">
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="URBI">
|
||
<tag/URBI/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.urbiforge.org/">
|
||
</itemize>
|
||
|
||
URBI is a Universal Real-time Behavior Interface and gives you a simple
|
||
but powerful way to control any robot or complex system like a video
|
||
game, using a convenient and easy to use scripting language that can be
|
||
interfaced with several popular programming languages (C++, Java,
|
||
Matlab,...) and OS (Windows, Mac OSX, Linux). URBI is based on a
|
||
client/server architecture, which give a great deal of flexibility.
|
||
URBI includes powerful features compared to existing scripting
|
||
solutions: parallel execution of commands, event programming, command
|
||
tagging, dynamic variables,... Currently, URBI is used as well by
|
||
academic research labs, the industry and by hobbyists.
|
||
|
||
|
||
<label id="VWORLD">
|
||
<tag/VWORLD/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://zhar.net/projects/vworld/">
|
||
</itemize>
|
||
|
||
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).
|
||
|
||
|
||
|
||
<label id="Yampa">
|
||
<tag/Yampa/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.haskell.org/yampa/"
|
||
name="http://www.haskell.org/yampa/">
|
||
</itemize>
|
||
|
||
FRP system with robotics library and graphical interactive robotics
|
||
simulator.
|
||
|
||
Functional reactive programming, or FRP, is a paradigm for programming
|
||
hybrid systems <20> i.e., systems containing a combination of both
|
||
continuous and discrete components <20> in a high-level, declarative way.
|
||
The key ideas in FRP are its notions of continuous, time-varying
|
||
values, and time-ordered sequences of discrete events. Yampa is an
|
||
instantiation of FRP as a domain-specific language embedded in Haskell.
|
||
|
||
|
||
<label id="YARP">
|
||
<tag/YARP/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://eris.liralab.it/yarp/">
|
||
</itemize>
|
||
|
||
YARP is plumbing for robot software. It is a set of libraries,
|
||
protocols, and tools to keep modules and devices cleanly decoupled. It
|
||
is reluctant middleware, with no desire or expectation to be in control
|
||
of your system.
|
||
|
||
More specifically, YARP supports building a robot control system as a
|
||
collection of programs communicating in a peer-to-peer way, with a
|
||
family of connection types that meet the diverse, sometimes
|
||
contradictory, and always changing needs of advanced robotics. We also
|
||
encourage compilation and use of hardware devices in a future-proof
|
||
way. Our strategic goal is to increase the longevity of robot software
|
||
projects.
|
||
|
||
|
||
|
||
</descrip>
|
||
|
||
<sect>Statistical & Machine Learning
|
||
<label id="Statistical & Machine Learning">
|
||
|
||
<p>
|
||
|
||
All about getting machines to learn to do something rather than
|
||
explicitly programming to do it. Tends to deal with pattern matching
|
||
a lot and are heavily math and statistically based. Technically
|
||
<ref id="Connectionism"> falls under this category, but it is such a
|
||
large sub-field I'm keeping it in a separate section.
|
||
|
||
|
||
<sect1>Libraries
|
||
<p>
|
||
|
||
Libraries or frameworks used for writing machine learning systems.
|
||
|
||
<descrip>
|
||
|
||
<label id="CognitiveFoundry">
|
||
<tag/CognitiveFoundry/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://foundry.sandia.gov/">
|
||
</itemize>
|
||
|
||
The Cognitive Foundry is a modular Java software library for the
|
||
research and development of cognitive systems. It contains many
|
||
reusable components for machine learning, statistics, and cognitive
|
||
modeling. It is primarily designed to be easy to plug into applications
|
||
to provide adaptive behaviors.
|
||
|
||
|
||
<label id="CompLearn">
|
||
<tag/CompLearn/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://complearn.org/">
|
||
</itemize>
|
||
|
||
CompLearn is a software system built to support compression-based
|
||
learning in a wide variety of applications. It provides this support in
|
||
the form of a library written in highly portable ANSI C that runs in
|
||
most modern computer environments with minimal confusion. It also
|
||
supplies a small suite of simple, composable command-line utilities as
|
||
simple applications that use this library. Together with other commonly
|
||
used machine-learning tools such as LibSVM and GraphViz, CompLearn
|
||
forms an attractive offering in machine-learning frameworks and
|
||
toolkits.
|
||
|
||
|
||
<label id="Elefant">
|
||
<tag/Elefant/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://elefant.developer.nicta.com.au/">
|
||
</itemize>
|
||
|
||
Elefant (Efficient Learning, Large-scale Inference, and Optimisation
|
||
Toolkit) is an open source library for machine learning licensed under
|
||
the Mozilla Public License (MPL). We develop an open source machine
|
||
learning toolkit which provides
|
||
|
||
<itemize>
|
||
<item>algorithms for machine learning utilising the power of
|
||
multi-core/multi-threaded processors/operating systems (Linux,
|
||
WIndows, Mac OS X),
|
||
<item>a graphical user interface for users who want to quickly
|
||
prototype machine learning experiments,
|
||
<item>tutorials to support learning about Statistical Machine
|
||
Learning (Statistical Machine Learning at The Australian National
|
||
University), and
|
||
<item>detailed and precise documentation for each of the above.
|
||
</itemize>
|
||
|
||
|
||
<label id="Maximum Entropy Toolkit">
|
||
<tag/Maximum Entropy Toolkit/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://homepages.inf.ed.ac.uk/lzhang10/maxent_toolkit.html">
|
||
</itemize>
|
||
|
||
The Maximum Entropy Toolkit provides a set of tools and library for
|
||
constructing maximum entropy (maxent) model in either Python or C++.
|
||
|
||
Maxent Entropy Model is a general purpose machine learning framework
|
||
that has proved to be highly expressive and powerful in statistical
|
||
natural language processing, statistical physics, computer vision and
|
||
many other fields.
|
||
|
||
|
||
<label id="Milk">
|
||
<tag/Milk/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://packages.python.org/milk/">
|
||
<item>Web site: <htmlurl
|
||
url="https://github.com/luispedro/milk">
|
||
</itemize>
|
||
|
||
Milk is a machine learning toolkit in Python. It's focus is on
|
||
supervised classification with several classifiers available: SVMs
|
||
(based on libsvm), k-NN, random forests, decision trees. It also
|
||
performs feature selection. These classifiers can be combined in many
|
||
ways to form different classification systems. For unsupervised
|
||
learning, milk supports k-means clustering and affinity propagation.
|
||
|
||
|
||
<label id="NLTK">
|
||
<tag/NLTK/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://nltk.org/">
|
||
</itemize>
|
||
|
||
NLTK, the Natural Language Toolkit, is a suite of Python libraries and
|
||
programs for symbolic and statistical natural language processing.
|
||
NLTK includes graphical demonstrations and sample data. It is
|
||
accompanied by extensive documentation, including tutorials that
|
||
explain the underlying concepts behind the language processing tasks
|
||
supported by the toolkit.
|
||
|
||
NLTK is ideally suited to students who are learning NLP (natural
|
||
language processing) or conducting research in NLP or closely related
|
||
areas, including empirical linguistics, cognitive science, artificial
|
||
intelligence, information retrieval, and machine learning. NLTK has
|
||
been used successfully as a teaching tool, as an individual study tool,
|
||
and as a platform for prototyping and building research systems.
|
||
|
||
|
||
<label id="peach">
|
||
<tag/peach/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://code.google.com/p/peach/">
|
||
</itemize>
|
||
|
||
Peach is a pure-python module, based on SciPy and NumPy to implement
|
||
algorithms for computational intelligence and machine learning. Methods
|
||
implemented include, but are not limited to, artificial neural
|
||
networks, fuzzy logic, genetic algorithms, swarm intelligence and much
|
||
more.
|
||
|
||
The aim of this library is primarily educational. Nonetheless, care was
|
||
taken to make the methods implemented also very efficient.
|
||
|
||
|
||
<label id="pebl">
|
||
<tag/pebl/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://code.google.com/p/pebl-project/">
|
||
</itemize>
|
||
|
||
Pebl is a python library and command line application for learning the
|
||
structure of a Bayesian network given prior knowledge and observations.
|
||
Pebl includes the following features:
|
||
|
||
<itemize>
|
||
<item>Can learn with observational and interventional data
|
||
<item>Handles missing values and hidden variables using exact and
|
||
heuristic methods
|
||
<item>Provides several learning algorithms; makes creating new ones
|
||
simple
|
||
<item>Has facilities for transparent parallel execution using several
|
||
cluster/grid resources
|
||
<item>Calculates edge marginals and consensus networks
|
||
<item>Presents results in a variety of formats
|
||
</itemize>
|
||
|
||
|
||
<label id="PyBrain">
|
||
<tag/PyBrain/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://pybrain.org/">
|
||
</itemize>
|
||
|
||
PyBrain is a modular Machine Learning Library for Python. It's goal is
|
||
to offer flexible, easy-to-use yet still powerful algorithms for
|
||
Machine Learning Tasks and a variety of predefined environments to test
|
||
and compare your algorithms.
|
||
|
||
PyBrain contains algorithms for neural networks, for reinforcement
|
||
learning (and the combination of the two), for unsupervised learning,
|
||
and evolution. Since most of the current problems deal with continuous
|
||
state and action spaces, function approximators (like neural networks)
|
||
must be used to cope with the large dimensionality. Our library is
|
||
built around neural networks in the kernel and all of the training
|
||
methods accept a neural network as the to-be-trained instance. This
|
||
makes PyBrain a powerful tool for real-life tasks.
|
||
|
||
|
||
<label id="MBT">
|
||
<tag/MBT/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ilk.uvt.nl/mbt/">
|
||
</itemize>
|
||
|
||
MBT is a memory-based tagger-generator and tagger in one. The
|
||
tagger-generator part can generate a sequence tagger on the basis of a
|
||
training set of tagged sequences; the tagger part can tag new
|
||
sequences. MBT can, for instance, be used to generate part-of-speech
|
||
taggers or chunkers for natural language processing. It has also been
|
||
used for named-entity recognition, information extraction in
|
||
domain-specific texts, and disfluency chunking in transcribed speech.
|
||
|
||
|
||
<label id="MLAP book samples">
|
||
<tag/MLAP book samples/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://seat.massey.ac.nz/personal/s.r.marsland/MLBook.html">
|
||
</itemize>
|
||
|
||
Not a library per-say, but a whole slew of example machine learning
|
||
algorithms from the book "Machine Learning: An Algorithmic Perspective"
|
||
by Stephen Marsland. All code is written in python.
|
||
|
||
|
||
<label id="scikits.learn">
|
||
<tag/scikits.learn/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://scikit-learn.org/stable/">
|
||
</itemize>
|
||
|
||
scikits-learn is a Python module integrating classic machine learning
|
||
algorithms in the tightly-knit world of scientific Python packages
|
||
(numpy, scipy, matplotlib). It aims to provide simple and efficient
|
||
solutions to learning problems that are accessible to everybody and
|
||
reusable in various contexts: machine-learning as a versatile tool for
|
||
science and engineering.
|
||
|
||
|
||
<label id="Shogun">
|
||
<tag/Shogun/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://www.shogun-toolbox.org/">
|
||
</itemize>
|
||
|
||
The machine learning toolbox's focus is on large scale kernel methods
|
||
and especially on Support Vector Machines (SVM). It provides a generic
|
||
SVM object interfacing to several different SVM implementations, among
|
||
them the state of the art LibSVM and SVMLight. Each of the SVMs can be
|
||
combined with a variety of kernels. The toolbox not only provides
|
||
efficient implementations of the most common kernels, like the Linear,
|
||
Polynomial, Gaussian and Sigmoid Kernel but also comes with a number of
|
||
recent string kernels as e.g. the Locality Improved, Fischer, TOP,
|
||
Spectrum, Weighted Degree Kernel (with shifts). For the latter the
|
||
efficient LINADD optimizations are implemented. Also SHOGUN offers the
|
||
freedom of working with custom pre-computed kernels. One of its key
|
||
features is the combined kernel which can be constructed by a weighted
|
||
linear combination of a number of sub-kernels, each of which not
|
||
necessarily working on the same domain. An optimal sub-kernel weighting
|
||
can be learned using Multiple Kernel Learning. Currently SVM 2-class
|
||
classification and regression problems can be dealt with. However
|
||
SHOGUN also implements a number of linear methods like Linear
|
||
Discriminant Analysis (LDA), Linear Programming Machine (LPM), (Kernel)
|
||
Perceptrons and features algorithms to train hidden markov models. The
|
||
input feature-objects can be dense, sparse or strings and of type
|
||
int/short/double/char and can be converted into different feature
|
||
types. Chains of preprocessors (e.g. substracting the mean) can be
|
||
attached to each feature object allowing for on-the-fly pre-processing.
|
||
|
||
SHOGUN is implemented in C++ and interfaces to Matlab(tm), R, Octave
|
||
and Python.
|
||
|
||
|
||
<label id="timbl">
|
||
<tag/timbl/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://ilk.uvt.nl/timbl/">
|
||
</itemize>
|
||
|
||
The Tilburg Memory Based Learner, TiMBL, is a tool for NLP research,
|
||
and for many other domains where classification tasks are learned from
|
||
examples. It is an efficient implementation of k-nearest neighbor
|
||
classifier.
|
||
|
||
TiMBL's features are:
|
||
<itemize>
|
||
<item>Fast, decision-tree-based implementation of k-nearest neighbor
|
||
lassification;
|
||
<item>Implementations of IB1 and IB2, IGTree, TRIBL, and TRIBL2
|
||
algorithms;
|
||
<item>Similarity metrics: Overlap, MVDM, Jeffrey Divergence, Dot
|
||
product, Cosine;
|
||
<item>Feature weighting metrics: information gain, gain ratio,
|
||
chi squared, shared variance;
|
||
<item>Distance weighting metrics: inverse, inverse linear,
|
||
exponential decay;
|
||
<item>Extensive verbosity options to inspect nearest neighbor sets;
|
||
<item>Server functionality and extensive API;
|
||
<item>Fast leave-one-out testing and internal cross-validation;
|
||
<item>and Handles user-defined example weighting.
|
||
</itemize>
|
||
|
||
|
||
</descrip>
|
||
|
||
<sect1>Applications
|
||
<p>
|
||
|
||
Full applications that implement various machine learning or statistical
|
||
systems oriented toward general learning (i.e., no spam filters and the
|
||
like).
|
||
|
||
<descrip>
|
||
|
||
<label id="dbacl">
|
||
<tag/dbacl/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://dbacl.sourceforge.net/">
|
||
</itemize>
|
||
|
||
The dbacl project consist of a set of lightweight UNIX/POSIX utilities
|
||
which can be used, either directly or in shell scripts, to classify
|
||
text documents automatically, according to Bayesian statistical
|
||
principles.
|
||
|
||
|
||
<label id="Torch">
|
||
<tag/Torch/
|
||
<itemize>
|
||
<item>Web site: <htmlurl url="http://www.torch.ch/">
|
||
<item>Old versions:
|
||
<htmlurl url="http://torch5.sourceforge.net/" name="Torch5">
|
||
<htmlurl url="http://www.torch.ch/torch3/" name="Torch3">
|
||
</itemize>
|
||
|
||
Torch provides a Matlab-like environment for state-of-the-art machine
|
||
learning algorithms. It is easy to use and provides a very efficient
|
||
implementation, thanks to an easy and fast scripting language (Lua) and
|
||
a underlying C implementation.
|
||
|
||
|
||
<label id="Vowpal Wabbit">
|
||
<tag/Vowpal Wabbit/
|
||
<itemize>
|
||
<item>Web site: <htmlurl
|
||
url="http://hunch.net/~vw/">
|
||
</itemize>
|
||
|
||
Vowpal Wabbit is a fast online learning algorithm. It features:
|
||
|
||
<itemize>
|
||
<item>flexible input data specification
|
||
<item>speedy learning
|
||
<item>scalability (bounded memory footprint, suitable for
|
||
distributed computation)
|
||
<item>feature pairing
|
||
</itemize>
|
||
|
||
The core algorithm is specialist gradient descent (GD) on a loss
|
||
function (several are available), The code should be easily usable.
|
||
|
||
|
||
</descrip>
|
||
|
||
<sect>Missing & Dead
|
||
<label id="Missing & Dead">
|
||
|
||
<p>
|
||
|
||
This is my area for old or bad entries. The MIA section is for entires for
|
||
which I no longer have a valid home page. If you have any information
|
||
regarding where I can find these now please let me know. The Dead section
|
||
is for projects that seem dead. Moving them here allows me to keep my
|
||
the main sections clean while allowing for interested parties to
|
||
correct me in which case I can just move it back.
|
||
|
||
<sect1>MIA - Projects missing linkage.
|
||
|
||
<p>
|
||
<descrip>
|
||
|
||
<label id="AntWars">
|
||
<tag/AntWars/
|
||
<itemize>
|
||
<item>Web site: http://ant-wars.net/
|
||
</itemize>
|
||
|
||
Ant Wars is a competition which pits clever programs against each
|
||
other to do battle and compete for food in virtual worlds. Each
|
||
contestant is a species of ant, which can visualize only the world
|
||
immediately around him and pheromones left by fellow and enemy ants.
|
||
Using this information, the ant brain (a simple state machine) must
|
||
guide the ant towards collecting food at his home ant hill, while
|
||
fending off or attacking enemies.
|
||
|
||
Clever use of pheromones and subtle behaviors can create large scale
|
||
tactics such as raiding, defense, harvesting, and scouting when many
|
||
ants cooperate.
|
||
|
||
|
||
<label id="CASE">
|
||
<tag/CASE/
|
||
<itemize>
|
||
<item>Web site: http://www.iu.hio.no/˜cell/
|
||
<item>FTP site: ftp://ftp.iu.hio.no/pub/
|
||
</itemize>
|
||
|
||
CASE (Cellular Automaton Simulation Environment) is a C++
|
||
toolkit for visualizing discrete models in two dimensions:
|
||
so-called cellular automata. The aim of this project is to
|
||
create an integrated framework for creating generalized cellular
|
||
automata using the best, standardized technology of the day.
|
||
|
||
|
||
<label id="CLEARS">
|
||
<tag/CLEARS/
|
||
<itemize>
|
||
<item>Web site: ????
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="CLIG">
|
||
<tag/CLIG/
|
||
<itemize>
|
||
<item>Web site: http://www.ags.uni-sb.de/˜konrad/clig.html
|
||
</itemize>
|
||
|
||
CLIG is an interactive, extendible grapher for visualizing linguistic
|
||
data structures like trees, feature structures, Discourse
|
||
Representation Structures (DRS), logical formulas etc. All of these can
|
||
be freely mixed and embedded into each other. The grapher has been
|
||
designed both to be stand-alone and to be used as an add-on for
|
||
linguistic applications which display their output in a graphical
|
||
manner.
|
||
|
||
|
||
<label id="Corewar VM">
|
||
<tag/Corewar VM/
|
||
<itemize>
|
||
<item>Web site: http://www.jedi.claranet.fr/
|
||
</itemize>
|
||
|
||
This is a virtual machine written in Java (so it is a virtual machine
|
||
for another virtual machine !) for a Corewar game.
|
||
|
||
|
||
<label id="DAI">
|
||
<tag/DAI/
|
||
<itemize>
|
||
<item>Web site: http://starship.python.net/crew/gandalf/DNET/AI/
|
||
</itemize>
|
||
|
||
A library for the Python programming language that provides an
|
||
object oriented interface to the CLIPS expert system tool. It
|
||
includes an interface to COOL (CLIPS Object Oriented Language)
|
||
that allows:
|
||
<itemize> <item>Investigate COOL classes</item>
|
||
<item>Create and manipulate with COOL instances</item>
|
||
<item>Manipulate with COOL message-handler's</item>
|
||
<item>Manipulate with Modules</item>
|
||
</itemize>
|
||
|
||
|
||
<label id="DHARMI">
|
||
<tag/DHARMI/
|
||
<itemize>
|
||
<item>Web site: http://megazone.bigpanda.com/˜wolf/DHARMI/
|
||
</itemize>
|
||
|
||
DHARMI is a high level spatial, tinker-toy like language who's
|
||
components are transparently administered by a background
|
||
process called the Habitat. As the name suggests, the language
|
||
was designed to make modelling prototypes and handle living
|
||
data. Programs can be modified while running. This is accomplished
|
||
by blurring the distinction between source code, program,
|
||
and data.
|
||
|
||
|
||
<label id="Dunce">
|
||
<tag/Dunce/
|
||
<itemize>
|
||
<item>Web site: http://www.boswa.com/boswabits/
|
||
</itemize>
|
||
|
||
Dunce is a simple chatterbot (conversational AI) and a language for
|
||
programming such chatterbots. It uses a basic regex pattern matching
|
||
and a semi-neural rule/response firing mechanism (with excitement/decay
|
||
cycles).
|
||
|
||
Dunce is listed about halfway down the page.
|
||
|
||
|
||
<label id="EcoSim">
|
||
<tag/EcoSim/
|
||
<itemize>
|
||
<item>Web site: http://www.offis.de/projekte/projekt.php?id=140
|
||
</itemize>
|
||
|
||
NOTE: the above web site has info on EcoSim but no code to download.
|
||
|
||
In EcoSim an ecosystem is described by all static and dynamic
|
||
properties of the individuals involved in the system as well as time
|
||
varying properties of the environment. Individuals change their state
|
||
over time or due to internal and external events. The environment is
|
||
also defined via dynamic objects which can change. Supports on the fly
|
||
analysis and animation of generated data. It is a C++ class library
|
||
designed to support individual-oriented modelling and simulation
|
||
of ecological systems.
|
||
|
||
|
||
<label id="Evo">
|
||
<tag/Evo/
|
||
<itemize>
|
||
<item>Web site: http://omicrongroup.org/evo/
|
||
</itemize>
|
||
|
||
Evo is a software development framework that allows developers to build
|
||
complex alife simulations. Using Evo, researchers can easily build
|
||
systems of independent agents interacting with one another and with
|
||
their environment. Evo implements biological operators such as genetic
|
||
recombination and mutation to evolve the behavior of agents so that
|
||
they are more adapted to their environment.
|
||
|
||
|
||
<label id="Grany-3">
|
||
<tag/Grany-3/
|
||
<itemize>
|
||
<item>Web site: http://zarb.org/~gc/html/grany.html
|
||
</itemize>
|
||
|
||
Grany-3 is a full-featured cellular automaton simulator, made in C++
|
||
with Gtk--, flex++/bison++, doxygen and gettext, useful to granular
|
||
media physicists.
|
||
|
||
|
||
<label id="IBAL">
|
||
<tag/IBAL/
|
||
<itemize>
|
||
<item>Web site: http://www.eecs.harvard.edu/˜avi/IBAL/
|
||
</itemize>
|
||
|
||
IBAL (pronounced "eyeball") is a general-purpose language for
|
||
probabilistic modeling, parameter estimation and decision making. It
|
||
generalizes Bayesian networks, hidden Markov models, stochastic context
|
||
free grammars, Markov decision processes, and allows many new
|
||
possibilities. It also provides a convenient programming-language
|
||
framework with libraries, automatic type checking and so on.
|
||
|
||
|
||
<label id="IDEAL">
|
||
<tag/IDEAL/
|
||
<itemize>
|
||
<item>Web site: http://yoda.cis.temple.edu:8080/ideal/
|
||
</itemize>
|
||
|
||
IDEAL is a test bed for work in influence diagrams and
|
||
Bayesian networks. It contains various inference algorithms
|
||
for belief networks and evaluation algorithms for influence
|
||
diagrams. It contains facilities for creating and editing
|
||
influence diagrams and belief networks.
|
||
|
||
IDEAL is written in pure Common Lisp and so it will run in
|
||
Common Lisp on any platform. The emphasis in writing IDEAL has
|
||
been on code clarity and providing high level programming
|
||
abstractions. It thus is very suitable for experimental
|
||
implementations which need or extend belief network
|
||
technology.
|
||
|
||
At the highest level, IDEAL can be used as a subroutine
|
||
library which provides belief network inference and influence
|
||
diagram evaluation as a package. The code is documented in a
|
||
detailed manual and so it is also possible to work at a lower
|
||
level on extensions of belief network methods.
|
||
|
||
IDEAL comes with an optional graphic interface written in
|
||
CLIM. If your Common Lisp also has CLIM, you can run the
|
||
graphic interface.
|
||
|
||
|
||
<label id="Illuminator">
|
||
<tag/Illuminator/
|
||
<itemize>
|
||
<item>Web site: http://documents.cfar.umd.edu/resources/source/illuminator.html
|
||
</itemize>
|
||
|
||
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:
|
||
<itemize>
|
||
<item>5 magnification levels for images</item>
|
||
<item>flagged characters and words</item>
|
||
<item>unicode support -- American, British, French, German,
|
||
Greek, Italian, MICR, Norwegian, Russian, Spanish, Swedish,
|
||
keyboards </item>
|
||
<item>reads DAFS, TIFF's, PDA's (image only)</item>
|
||
<item>save to DAFS, ASCII/UTF or Unicode</item>
|
||
<item>Entity Viewer - shows properties, character choices,
|
||
bounding boxes image fragment for a selected entity, change
|
||
type, change content, hierarchy mode</item>
|
||
</itemize>
|
||
|
||
|
||
<label id="Jet's Neural Architecture">
|
||
<tag/Jet's Neural Architecture/
|
||
<itemize>
|
||
<item>Web site: http://www.voltar-confed.org/jneural/
|
||
</itemize>
|
||
|
||
Jet's Neural Architecture is a C++ framework for doing neural net
|
||
projects. The goals of this project were to make a fast, flexible
|
||
neural architecture that isn't stuck to one kind of net and to make
|
||
sure that end users could easily write useful applications. All the
|
||
documentation is also easily readable.
|
||
|
||
|
||
<label id="Neural Networks at your Fingertips">
|
||
<tag/Neural Networks at your Fingertips/
|
||
<itemize>
|
||
<item>Web site: http://www.neural-networks-at-your-fingertips.com/
|
||
</itemize>
|
||
|
||
A set of ANSI C packages that illustrate Adaline networks,
|
||
back-propagation, the Hopfield model, BAM, Boltzman, CPN, SOM, and
|
||
ART1. Coded in portable, self-contained ANSI C. With complete example
|
||
applications from a variety of well-known application domains.
|
||
|
||
|
||
<label id="Neureka ANS">
|
||
<tag/Neureka ANS (nn/xnn)/
|
||
<itemize>
|
||
<item>FTP site: ftp://ftp.ii.uib.no/pub/neureka/
|
||
</itemize>
|
||
|
||
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).
|
||
|
||
|
||
<label id="NEURObjects">
|
||
<tag/NEURObjects/
|
||
<itemize>
|
||
<item>Web site: http://www.disi.unige.it/person/ValentiniG/NEURObjects/
|
||
</itemize>
|
||
|
||
NEURObjects is a set of C++ library classes for neural networks
|
||
development. The main goal of the library consists in supporting
|
||
researchers and practitioners in developing new neural network methods
|
||
and applications, exploiting the potentialities of object-oriented
|
||
design and programming. NEURObjects provides also general purpose
|
||
applications for classification problems and can be used for fast
|
||
prototyping of inductive machine learning applications.
|
||
|
||
|
||
<label id="OSCAR">
|
||
<tag/OSCAR/
|
||
<itemize>
|
||
<item>Web site: http://oscarhome.soc-sci.arizona.edu/ftp/OSCAR-web-page/oscar.html
|
||
</itemize>
|
||
|
||
The goal of the OSCAR project is the formulation of a general theory of
|
||
rationality and its implementation in an artificial rational agent. The
|
||
function of artificial agents is to draw conclusions and make decisions
|
||
on the basis of information supplied to them. OSCAR is a fully
|
||
implemented architecture for rational agents, based upon a general
|
||
purpose defeasible reasoner. OSCAR is written in Common Lisp and is
|
||
free for educational and research purposes.
|
||
|
||
|
||
<label id="PAI">
|
||
<tag/PAI/
|
||
<itemize>
|
||
<item>Web site: http://utenti.quipo.it/claudioscordino/pai.html
|
||
</itemize>
|
||
|
||
AI (Programmable Artificial Intelligence) is a program capable of
|
||
having a conversation in its mother tongue, English. Written in
|
||
C++.
|
||
|
||
|
||
<label id="pygene">
|
||
<tag/pygene/
|
||
<itemize>
|
||
<item>Web site: http://www.freenet.org.nz/python/pygene/
|
||
</itemize>
|
||
|
||
pygene is a simple and easily understandable library for genetic
|
||
algorithms and genetic programming in python. Includes examples
|
||
such as the travelling salesman problem.
|
||
|
||
|
||
<label id="PyIE">
|
||
<tag/PyIE/
|
||
<itemize>
|
||
<item>repo: https://www.dfwpython.org/repo/Projects/PyIE/
|
||
</itemize>
|
||
|
||
PyIE is a hypothesis based, agenda driven, object oriented inference
|
||
engine written in Python. Inferencing modes include back chaining,
|
||
opportunistic forward chaining and explicit forward chaining. The
|
||
first-class object base supports metaclasses, classes, objects and
|
||
multiple, dynamic inheritance. All objects are first class objects and
|
||
all attributes are slot values, i.e. data members attached to some
|
||
object.
|
||
|
||
PyIE uses a TMS (truth maintenance system) for first level (condition
|
||
change) non-monotonic reasoning. User defined metaclasses are being
|
||
explored to support second level (belief change) non-monotonic
|
||
reasoning.
|
||
|
||
|
||
<label id="Python ANN">
|
||
<tag/Simple Neural Net (in Python)/
|
||
<itemize>
|
||
<item>Web site: http://www.amk.ca/python/unmaintained/
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Python Fuzzy Logic Module">
|
||
<tag/Python Fuzzy Logic Module/
|
||
<itemize>
|
||
<item>FTP site: ftp://ftp.csh.rit.edu/pub/members/retrev/
|
||
</itemize>
|
||
|
||
A simple python module for fuzzy logic. The file is 'fuz.tar.gz' in
|
||
this directory. The author plans to also write a simple genetic
|
||
algorithm and a neural net library as well. Check the 00_index file in
|
||
this directory for release info.
|
||
|
||
|
||
<label id="QUANT1">
|
||
<tag/QUANT1/
|
||
<itemize>
|
||
<item>Web site: http://linux.irk.ru/projects/QUANT/
|
||
</itemize>
|
||
|
||
This project seems to have gone proprietary. The only trace I can find
|
||
via google is at
|
||
http://www.zurich.co.uk/strategicrisk/softwaresupport/Quant1.htm.
|
||
|
||
QUANT/1 stands for type QUANTifier. It aims to be an alternative to
|
||
Prolog-like (Resulutional-like) systems. Main features include a lack
|
||
of necessity for eliminating Quantifiers, scolemisation, ease of
|
||
comprehension, large scale formulae operation, acceptance of nonHorn
|
||
formulaes, and Iterative deeping. The actual library implemented in
|
||
this project is called ATPPCF (Automatic Theorem Prover in calculus of
|
||
Positively Constructed Formulae).
|
||
|
||
ATPPCF will be a library (inference engine) and an extension of the
|
||
Predicate Calculus Language as a new logical language. The library will
|
||
be incorporable in another software such as TCL, Python, Perl. The
|
||
engine's primary inference method will be the "search of inference in
|
||
language of Positively Constructed Formulas (PCFs)" (a subset of
|
||
Predicate Calculus well translated in both directions). The language
|
||
will be used as scripting language to the engine. But there will be
|
||
possibility to replace it with extensions languages of main software.
|
||
|
||
|
||
<label id="SCNN">
|
||
<tag/SCNN/
|
||
<itemize>
|
||
<item>Web site: http://www.uni-frankfurt.de/fb13/iap/e_ag_rt/SCNN/
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="SPI">
|
||
<tag/Symbolic Probabilistic Inference (SPI)/
|
||
<itemize>
|
||
<item>FTP site: ftp://ftp.engr.orst.edu/pub/dambrosi/spi/
|
||
<item>Paper (ijar-94.ps): ftp://ftp.engr.orst.edu/pub/dambrosi/
|
||
</itemize>
|
||
|
||
Contains Common Lisp function libraries to implement SPI type baysean
|
||
nets. Documentation is very limited.
|
||
Features:
|
||
<itemize>
|
||
Probabilities, Local Expression Language Utilities, Explanation,
|
||
Dynamic Models, and a TCL/TK based GUI.
|
||
</itemize>
|
||
|
||
|
||
<label id="SPRLIB-ANNLIB">
|
||
<tag/SPRLIB/ANNLIB/
|
||
<itemize>
|
||
<item>Web site: http://www.ph.tn.tudelft.nl/˜sprlib/
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Sugal">
|
||
<tag/Sugal/
|
||
<itemize>
|
||
<item>Web site: http://www.trajan-software.demon.co.uk/sugal.htm
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="ThoughtTreasure">
|
||
<tag/ThoughtTreasure/
|
||
<itemize>
|
||
<item>Web site: http://www.signiform.com/tt/htm/tt.htm
|
||
</itemize>
|
||
|
||
ThoughtTreasure is a project to create a database of commonsense rules
|
||
for use in any application. It consists of a database of a little over
|
||
100K rules and a C API to integrate it with your applications. Python,
|
||
Perl, Java and TCL wrappers are already available.
|
||
|
||
|
||
<label id="TIN">
|
||
<tag/TIN/
|
||
<itemize>
|
||
<item>Web site: http://www.jetlag.demon.nl/
|
||
</itemize>
|
||
|
||
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.
|
||
|
||
|
||
<label id="Ummon">
|
||
<tag/Ummon/
|
||
<itemize>
|
||
<item>Web site: http://www.spacetide.com/projects/ummon/
|
||
</itemize>
|
||
|
||
Ummon is an advanced Open Source chatterbot. The main principle of the
|
||
bot is that it has no initial knowledge of either words or grammar; it
|
||
learns everything "on the fly." Numerous AI techniques will be explored
|
||
in the development of Ummon to achieve realistic "human" communication
|
||
with support for different, customizable personalities.
|
||
|
||
|
||
<label id="ViSe">
|
||
<tag/Virtual Secretary Project (ViSe)/ (Tcl/Tk)
|
||
<itemize>
|
||
<item>Web site: http://www.vise.cs.uit.no/vise/
|
||
</itemize>
|
||
|
||
The motivation of the Virtual Secretary project is to construct
|
||
user-model-based intelligent software agents, which could in
|
||
most cases replace human for secretarial tasks, based on modern
|
||
mobile computing and computer network. The project includes two
|
||
different phases: the first phase (ViSe1) focuses on information
|
||
filtering and process migration, its goal is to create a secure
|
||
environment for software agents using the concept of user
|
||
models; the second phase (ViSe2) concentrates on agents'
|
||
intelligent and efficient cooperation in a distributed
|
||
environment, its goal is to construct cooperative agents for
|
||
achieving high intelligence. (Implemented in Tcl/TclX/Tix/Tk)
|
||
|
||
|
||
<label id="Zeus">
|
||
<tag/Zeus/
|
||
<itemize>
|
||
<item>Web site: http://more.btexact.com/projects/agents/zeus/
|
||
</itemize>
|
||
|
||
The construction of multi-agent systems involves long development
|
||
times and requires solutions to some considerable technical
|
||
difficulties. This has motivated the development of the ZEUS
|
||
toolkit, which provides a library of software components and tools
|
||
that facilitate the rapid design, development and deployment of
|
||
agent system
|
||
|
||
|
||
</descrip>
|
||
|
||
|
||
<sect1>Dead projects.
|
||
|
||
<p>
|
||
<descrip>
|
||
|
||
|
||
<label id="FIPA-OS">
|
||
<tag/FIPA-OS/
|
||
<itemize>
|
||
<item>Web site: http://fipa-os.sourceforge.net/index.htm
|
||
</itemize>
|
||
|
||
FIPA-OS is an open source implementation of the mandatory elements
|
||
contained within the FIPA specification for agent interoperability. In
|
||
addition to supporting the FIPA interoperability concepts, FIPA-OS also
|
||
provides a component based architecture to enable the development of
|
||
domain specific agents which can utilise the services of the FIPA
|
||
Platform agents. It is implemented in Java.
|
||
|
||
|
||
<label id="PDKB">
|
||
<tag/PDKB/
|
||
<itemize>
|
||
<item>Web site: http://lynx.eaze.net/˜pdkb/web/
|
||
<item>SourceForge site: http://sourceforge.net/projects/pdkb/
|
||
</itemize>
|
||
|
||
Public Domain Knowledge Bank (PDKB) is an Artificial Intelligence
|
||
Knowledge Bank of common sense rules and facts. It is based on the Cyc
|
||
Upper Ontology and the MELD language.
|
||
|
||
|
||
<label id="RobocodeNG">
|
||
<tag/RobocodeNG/
|
||
<itemize>
|
||
<item>Web site: http://robocodeng.sourceforge.net/
|
||
</itemize>
|
||
|
||
Merged together with original <ref id="Robocode"> as of version 1.1.
|
||
|
||
Extension of Robocode, the battling bot AI programming game. Like its
|
||
parent, it is written in Java and meant as a learning environment.
|
||
|
||
|
||
<label id="Sulawesi">
|
||
<tag/Sulawesi/
|
||
<itemize>
|
||
<item>Web site: http://wearables.essex.ac.uk/sulawesi/
|
||
</itemize>
|
||
|
||
A framework called Sulawesi has been designed and implemented to
|
||
tackle what has been considered to be important challenges in a
|
||
wearable user interface. The ability to accept input from any
|
||
number of modalities, and perform if necessary a translation to any
|
||
number of modal outputs. It does this primarily through a set
|
||
of proactive agents to act on the input.
|
||
|
||
|
||
<label id="TresBel">
|
||
<tag/TresBel/
|
||
<itemize>
|
||
<item>Abstract: http://iridia.ulb.ac.be/Projects/imple.html
|
||
<item>Direct Download: ftp://iridia.ulb.ac.be/pub/hongxu/software/TresBel.tar.Z
|
||
</itemize>
|
||
|
||
This project seems to have been superseded by <ref id="Pulcinella">.
|
||
|
||
Libraries containing (Allegro) Common Lisp code for Belief Functions
|
||
(aka. Dempster-Shafer evidential reasoning) as a representation
|
||
of uncertainty. Very little documentation. Has a limited GUI.
|
||
|
||
|
||
</descrip>
|
||
|
||
</article>
|