GNU/Linux AI & Alife HOWTO - John Eikenberry (best mystery novels of all time txt) 📗

class="calibre1">XNBC

 

� Web site: www.b3e.jussieu.fr/xnbc/

 

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.

4. Evolutionary Computing

Evolutionary computing is actually a broad term for a vast array of

programming techniques, including genetic algorithms, complex adaptive

systems, evolutionary programming, etc. The main thrust of all these

techniques is the idea of evolution. The idea that a program can be

written that will evolve toward a certain goal. This goal can be

anything from solving some engineering problem to winning a game.

 

4.1. EC class/code libraries

 

These are libraries of code or classes for use in programming within

the evolutionary computation field. They are not meant as stand alone

applications, but rather as tools for building your own applications.

 

ANNEvolve

 

� Web site: annevolve.sourceforge.net

 

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.

 

daga

 

� Web site: garage.cps.msu.edu/software/daga3.2/

 

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.

 

dgpf

 

� Web site: dgpf.sourceforge.net

 

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.

 

Ease

 

� Web site: www.sprave.com/Ease/Ease.html

 

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.

 

EO

 

� Web site: eodev.sourceforge.net

 

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.

 

FORTRAN GA

 

� Web site: cuaerospace.com/carroll/ga.html

 

This program is a FORTRAN version of a genetic algorithm driver.

This code initializes a random sample of individuals with

different parameters to be optimized using the genetic algorithm

approach, i.e. evolution via survival of the fittest. The

selection scheme used is tournament selection with a shuffling

technique for choosing random pairs for mating. The routine

includes binary coding for the individuals, jump mutation, creep

mutation, and the option for single-point or uniform crossover.

Niching (sharing) and an option for the number of children per

pair of parents has been added. More recently, an option for

the use of a micro-GA has been added.

 

GAlib: Matthew’s Genetic Algorithms Library

 

� Web Site: lancet.mit.edu/ga/

 

� Download: lancet.mit.edu/ga/dist/

 

� Register GAlib at: lancet.mit.edu/ga/Register.html

 

GAlib contains a set of C++ genetic algorithm objects. The

library includes tools for using genetic algorithms to do

optimization in any C++ program using any representation and

genetic operators. The documentation includes an extensive

overview of how to implement a genetic algorithm as well as

examples illustrating customizations to the GAlib classes.

 

GALOPPS

 

� Web site: garage.cps.msu.edu/software/galopps/

 

� FTP site: garage.cps.msu.edu/pub/GA/galopps/

 

GALOPPS is a flexible, generic GA, in ‘C’. It was based upon

Goldberg’s Simple Genetic Algorithm (SGA) architecture, in order

to make it easier for users to learn to use and extend.

 

GALOPPS extends the SGA capabilities several fold:

 

� (optional) A new Graphical User Interface, based on TCL/TK,

for Unix users, allowing easy running of GALOPPS 3.2 (single

or multiple subpopulations) on one or more processors. GUI

writes/reads “standard” GALOPPS input and master files, and

displays graphical output (during or after run) of user-selected variables.

 

� 5 selection methods: roulette wheel, stochastic remainder

sampling, tournament selection, stochastic universal

sampling, linear-ranking-then-SUS.

 

� Random or superuniform initialization of “ordinary” (non-permutation) binary or non-binary chromosomes; random

initialization of permutation-based chromosomes; or user-supplied initialization of arbitrary types of chromosomes.

 

� Binary or non-binary alphabetic fields on value-based

chromosomes, including different user-definable field sizes.

 

� 3 crossovers for value-based representations: 1-pt, 2-pt, and

uniform, all of which operate at field boundaries if a non-binary alphabet is used.

 

� 4 crossovers for order-based reps: PMX, order-based, uniform

order-based, and cycle.

 

� 4 mutations: fast bitwise, multiple-field, swap and random

sublist scramble.

 

� Fitness scaling: linear scaling, Boltzmann scaling, sigma

truncation, window scaling, ranking.

 

� Plus a whole lot more….

 

GAS

 

� Web site: starship.skyport.net/crew/gandalf

 

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.

 

GAUL

 

� Web site: gaul.sourceforge.net

 

� SF project site: sourceforge.net/projects/gaul/

 

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:

 

� Darwinian, Lamarckian or Baldwinian evolutionary schemes.

 

� Both steady-state and generation-based GAs included.

 

� The island model of evolution is available.

 

� Chromosome datatype agnostic. A selection of common

chromosome types are builtin.

 

� Allows user-defined crossover, mutation, selection,

adaptation and replacement operators.

 

� Support for multiple, simultaneously evolved,populations.

 

� Choice of high-level or low-level interface functions.

 

� Additional, non-GA, optimisation algorithms are builtin for

local optimisation or comparative purposes.

 

� Trivial to extend using external code via the builtin code

hooks.

 

� May be driven by, or extended by, powerful S-Lang scripts.

 

� Support for multiprocessor calculations.

 

� Written using highly portable C code.

 

GECO

 

� FTP site: common-lisp.net/project/geco/

 

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.

 

Genetic

 

� Web site: ???

 

� You can get it from the debian repository:

packages.qa.debian.org/g/genetic.html

 

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).

 

GPdata

 

� FTP site: ftp.cs.bham.ac.uk/pub/authors/W.B.Langdon/gp-code/

 

� Documentation (GPdata-icga-95.ps):

cs.ucl.ac.uk/genetic/papers/

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:

 

� Indexed memory operation (cf. teller)

 

� multi tree programs

 

� Adfs

 

� parameter changes without recompilation

 

� populations partitioned into demes

 

� (A version of) pareto fitness

 

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.

 

gpjpp Genetic Programming in Java

 

� The code can be found in the tarball linked from “GP and

Othello Java code and READMEs” on this page:

http://www1.cs.columbia.edu/~evs/ml/hw4.html

 

gpjpp is a Java package I wrote for doing research in genetic

programming. It is a port of the gpc++ kernel written by Adam

Fraser and Thomas Weinbrenner. Included in the package are four

of Koza’s standard examples: the artificial ant, the hopping

lawnmower, symbolic regression, and the boolean multiplexer.

Here is a partial list of its features:

 

� graphic output of expression trees

 

� efficient diversity checking

 

� Koza’s greedy over-selection option for large populations

 

� extensible GPRun class that encapsulates most details of a

genetic programming test

 

� more robust and efficient streaming code, with automatic

checkpoint and restart built into the GPRun class

 

� an explicit complexity limit that can be set on each GP

 

� additional configuration variables to allow more testing

without recompilation

 

� support for automatically defined functions (ADFs)

 

� tournament and fitness proportionate selection

 

� demetic grouping

 

� optional steady state population

 

� subtree crossover

 

� swap and shrink mutation

 

jaga

 

� Web site: cs.felk.cvut.cz/~koutnij/studium/jaga/jaga.html

 

Simple genetic algorithm package written in Java.

 

lil-gp

 

� Web site: garage.cps.msu.edu/software/lil-gp/

 

� FTP site: garage.cps.msu.edu/pub/GA/lilgp/

 

patched lil-gp *

 

� Web site: www.cs.umd.edu/users/seanl/gp/

 

lil-gp is a generic ‘C’ genetic programming tool. It was written

with a number of goals in mind: speed, ease of use and support

for a number of options including:

 

� Generic ‘C’ program that runs on UNIX workstations

 

� Support for multiple population experiments, using arbitrary

and user settable topologies for exchange, for a single

processor (i.e., you can do multiple population gp

experiments on your PC).

 

� lil-gp manipulates trees of function pointers which are

allocated in single, large memory blocks for speed and to

avoid swapping.

 

* The patched lil-gp kernel is strongly-typed, with modifications on multithreading, coevolution, and other tweaks and features.

 

Lithos

 

� Web site: www.esatclear.ie/~rwallace/lithos.html

 

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.

 

Open BEAGLE

 

� Web site: beagle.gel.ulaval.ca

 

Open BEAGLE is a C++ evolutionary computation framework. It

provides a high-level software environment to do any kind of

evolutionary computation, with support