Importing code into GIT

Author: Tomasz bla Fortuna

.gitignore

@@ -0,0 +1 @@
+*.pyc

BUGS

@@ -0,0 +1,6 @@
+
+Bugs?
+
+Plenty of bugs to pick over, from design right
+through to coding
+

CHANGELOG

@@ -0,0 +1,46 @@
+Changelog for pygene
+
+December 12, 2005
+
+    - version 0.2.1
+
+        - renamed Organism class to MendelOrganism, to indicate
+          that it is based on a 'double-helix' eukaryotic model
+        - created Organism class, which uses only single helix
+          (single genes, not gene pairs)
+
+December 11, 2005
+
+    - version 0.2
+        - added genetic programming!!
+            - with working example
+        - changed mutation behaviour
+            - previously, child organisms were mutated in-place
+            - now, .mutate() on organisms returns a mutated copy
+        - changed crossover behaviour
+            - previously, crossover mating only returned one child
+            - now, crossover mating returns 2 children, so no
+              genetic material is lost
+
+
+December 9, 2005
+
+    - version 0.1.1
+        - added more primitive Gene subclasses
+        - replaced typeless 'gene names' list in Organisms
+          with a .genome dict
+        - added XML dump capability for genes, organisms and
+          populations
+        - added 'incest' feature, where high-fitness parents
+          can stay in the population and mate with their
+          children
+        - added option for spontaneous appearance of new
+          random organisms
+        - simplified the creation of random organisms
+
+December 6, 2005
+
+    - version 0.1
+
+        - first release
+

COPYING

@@ -0,0 +1,8 @@
+
+pygene is written by David McNab <david@freenet.org.nz>
+and is released under the GNU General Public License version 2, the
+text of which is available from the GNU Website: http://www.gnu.org
+
+Enquiries regarding commercial licenses are welcome, we
+can agree on a package to suit your project and markets
+

CREDITS

@@ -0,0 +1,3 @@
+
+pygene was written by David McNab <david@freenet.org.nz>
+

INSTALL

@@ -0,0 +1,16 @@
+
+INSTALL file for pygene
+
+Prerequisites:
+ - python 2.3 or later
+
+This is a python distutils-compliant package.
+
+To install it, become root and type:
+
+  python setup.py install
+
+If you want to run the gui version of the
+travelling salesman problem, you'll need to
+install fltk (fltk.sf.net) and pyfltk (pyfltk.sf.net)
+

README

@@ -0,0 +1,43 @@
+
+Overview:
+--------
+
+pygene is my attempt at a genetic algorithms
+and genetic programming library
+for python that is easy to use and understand
+
+This is your chance to play God.
+
+You design the genome of a species.
+
+You implement a fitness calculation procedure
+for members of that species.
+
+You create a population of that species,
+then sit back as members of the species indulge
+their promiscuous desires.
+
+A given organism's chance of getting laid is proportional
+tno its fitness.
+
+Watch as your population evolves closer and closer
+to perfection, or converges to something reasonably close
+to it.
+
+Documentation:
+-------------
+
+To get your nice HTML doco, type:
+
+  ./makedoc.py
+
+
+Examples:
+--------
+
+There are some examples in the toplevel directory, including:
+ - Travelling Salesman Problem (console and graphical versions)
+ - simple converger
+ - string guesser
+ - function deriver (genetic programming)
+

demo_converge.py

@@ -0,0 +1,71 @@
+#! /usr/bin/env python
+
+"""
+Very simple demo in which organisms try to minimise
+the output value of a function
+"""
+
+from pygene.gene import FloatGene, FloatGeneMax
+from pygene.organism import Organism, MendelOrganism
+from pygene.population import Population
+
+class CvGene(FloatGeneMax):
+    """
+    Gene which represents the numbers used in our organism
+    """
+    # genes get randomly generated within this range
+    randMin = -100.0
+    randMax = 100.0
+    
+    # probability of mutation
+    mutProb = 0.1
+    
+    # degree of mutation
+    mutAmt = 0.1
+
+
+class Converger(MendelOrganism):
+    """
+    Implements the organism which tries
+    to converge a function
+    """
+    genome = {'x':CvGene, 'y':CvGene}
+    
+    def fitness(self):
+        """
+        Implements the 'fitness function' for this species.
+        Organisms try to evolve to minimise this function's value
+        """
+        return self['x'] ** 2 + self['y'] ** 2
+
+    def __repr__(self):
+        return "<Converger fitness=%f x=%s y=%s>" % (
+            self.fitness(), self['x'], self['y'])
+
+
+# create an empty population
+
+pop = Population(species=Converger, init=2, childCount=50, childCull=20)
+
+
+# now a func to run the population
+
+def main():
+    try:
+        while True:
+            # execute a generation
+            pop.gen()
+
+            # get the fittest member
+            best = pop.best()
+            
+            # and dump it out
+            print best
+
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == '__main__':
+    main()
+

demo_fractal.py

@@ -0,0 +1,186 @@
+#! /usr/bin/env python
+
+"""
+experiment in using fractals to fit a set of values
+
+may or may not work
+"""
+
+import math
+
+from pygene.gene import FloatGene, ComplexGene
+from pygene.gene import IntGene, OrBitGene, rndPair
+from pygene.organism import Organism
+from pygene.population import Population
+
+# data set to model
+
+targetData = [432, 444, 520, 419, 450, 540, 625]
+targetDataLen = len(targetData)
+
+# gene classes for fractals
+
+class OrgGene(ComplexGene):
+    """
+    gene to use for initial value
+    """
+    mutProb = 0.03
+    mutAmt = 0.5
+
+    randMin = -2.0
+    randMax = 2.0
+
+class DeltaGene(ComplexGene):
+    """
+    gene to use for motion
+    """
+    mutProb = 0.03
+    mutAmt = 1.0
+
+    rndMin = -0.4
+    rndMax = 0.4
+
+
+class IterationsGene(IntGene):
+    """
+    gene that controls number of mandelbrot iterations
+    """
+    mutProb = 0.001
+    randMin = 2
+    randMax = 10
+
+# utility func - standard deviation
+
+def sdev(dataset):
+    
+    n = float(len(dataset))
+    mean = sum(dataset) / n
+    devs = [(x - mean) ** 2 for x in dataset]
+    sd = math.sqrt(sum(devs) / n)
+    return mean, sd
+    
+# organism class
+
+class FracOrganism(Organism):
+    """
+    organism class
+    """
+    genome = {
+        'init':OrgGene,
+        'delta':DeltaGene,
+        'iterations':IterationsGene,
+        )
+
+    maxIterations = 100
+
+    def fitness(self):
+        """
+        fitness is the standard deviation of the ratio of
+        each generated value to each target value
+        """
+        guessData = self.getDataSet()
+        badness = 0.0
+        ratios = [100000.0 * guessData[i] / targetData[i] \
+            for i in xrange(targetDataLen)]
+        try:
+            sd, mean = sdev(ratios)
+            var = sd / mean
+            badness = var, sd, mean
+        except:
+            #raise
+            badness = 10000.0, None, None
+        return badness
+        
+    def getDataSet(self):
+        """
+        computes the data set resulting from genes
+        """
+        guessData = []
+        org = self['init']
+        delta = self['delta']
+        niterations = self['iterations']
+        for i in xrange(targetDataLen):
+            #guessData.append(self.mand(org, niterations))
+            guessData.append(self.mand(org))
+            org += delta
+        return guessData
+    
+    def mand_old(self, org, niterations):
+        """
+        performs the mandelbrot calculation on point org for
+        niterations generations,
+        returns final magnitude
+        """
+        c = complex(0,0)
+        
+        for i in xrange(niterations):
+            c = c * c + org
+        
+        return abs(c)
+
+    def mand(self, org):
+        """
+        returns the number of iterations needed for abs(org)
+        to exceed 1.0
+        """
+        i = 0
+        c = complex(0,0)
+        while i < self.maxIterations:
+            if abs(c) > 1.0:
+                break
+            c = c * c + org
+            i += 1
+        return i
+            
+def newOrganism(self=None):
+
+    return FracOrganism(
+        init=OrgGene,
+        delta=DeltaGene,
+        iterations=IterationsGene,
+        )
+
+class FracPopulation(Population):
+
+    species = FracOrganism
+    initPopulation = 100
+
+    # cull to this many children after each generation
+    childCull = 6
+
+    # number of children to create after each generation
+    childCount = 30
+
+    # enable addition of random new organisms
+    newOrganism = newOrganism
+    numNewOrganisms = 5
+
+    # keep best 5 parents    
+    incest = 5
+
+
+# create an initial random population
+
+pop = FracPopulation()
+
+
+# now a func to run the population
+def main():
+    try:
+        while True:
+            # execute a generation
+            pop.gen()
+
+            # and dump it out
+            #print [("%.2f %.2f" % (o['x1'], o['x2'])) for o in pop.organisms]
+            best = pop.organisms[0]
+            print "fitness=%s" % (best.fitness(),)
+
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == '__main__':
+    main()
+
+