Pygene migrated to Python 3.

All examples executed (except for GUI salesman)

Author: Tomasz bla Fortuna

examples3/demo_case.py

@@ -0,0 +1,165 @@
+#! /usr/bin/env python3
+"""
+demo that tries to show one reason why genetic algorithms are successful.
+
+It tries to crack open a suitcase with a few locks, each with 1-5
+digits.  Fitness function can only determine that the lock is open, not
+the progress of opening the lock (how much the lock is opened)
+
+Genetic algorithm can keep partial results (e.g. 1 lock open) while
+trying other locks.
+
+In general each lock represents a partial solution to the problem
+described by organism.
+"""
+
+import random
+from time import time
+import sys
+
+from pygene3.gene import IntGene, IntGeneRandom, IntGeneExchange
+from pygene3.organism import Organism, GenomeSplitOrganism
+from pygene3.population import Population
+
+# Parameters
+locks = 8
+digits_in_lock = 3
+
+# Generate codes
+codes = []
+for lock in range(locks):
+    code = [random.randint(0, 9) for i in range(digits_in_lock)]
+    codes.append(code)
+
+
+class DigitCodeGene(IntGeneRandom):
+    """
+    a gene which holds a single digit, and can mutate into another digit.
+    Mutation randomizes gene for IntGeneRandom class.
+    """
+    mutProb = 0.3
+    # mutAmt = 2
+    randMin = 0
+    randMax = 9
+
+    def __repr__(self):
+        return str(self.value)
+
+# generate a genome, one gene for each digit in suitcase
+genome = {}
+for l in range(locks):
+    for d in range(digits_in_lock):
+        key = '%d_%d' % (l, d)
+        genome[key] = DigitCodeGene
+
+# an organism that evolves towards the required string
+
+class CodeHacker(GenomeSplitOrganism):
+
+    chromosome_intersections = 2
+    genome = genome
+
+    def get_code(self, lock):
+        "Decode the chromosome (genome) into code for specific lock"
+        code = []
+        for d in range(digits_in_lock):
+            key = '%d_%d' % (lock, d)
+            code.append(self[key])
+        return code
+
+    def fitness(self):
+        "calculate fitness - number of locks opened by genome."
+        opened_locks = 0
+        for l in range(locks):
+            code = self.get_code(l)
+            if code == codes[l]:
+                opened_locks += 1
+
+        # The lower the better
+        # add 0 - 0.5 to force randomization of organisms selection
+        fitness = float(locks - opened_locks) #+ random.uniform(0, 0.5)
+        return fitness
+
+    def __repr__(self):
+        "Display result nicely"
+        s='<CodeHacker '
+        for l in range(locks):
+            code = self.get_code(l)
+            code_str = "".join(str(i) for i in code)
+            if code == codes[l]:
+                s += " %s " % code_str # space - opened lock
+            else:
+                s += "(%s)" % code_str # () - closed lock
+        s = s.strip() + ">"
+        return s
+
+
+class CodeHackerPopulation(Population):
+    "Configuration of population"
+    species = CodeHacker
+
+    initPopulation = 500
+
+    # Tips: Leave a space for mutants to live.
+
+    # cull to this many children after each generation
+    childCull = 600
+
+    # number of children to create after each generation
+    childCount = 500
+
+    # Add this many mutated organisms.
+    mutants = 1.0
+
+    # Mutate organisms after mating (better results with False)
+    mutateAfterMating = False
+
+    numNewOrganisms = 0
+
+    # Add X best parents into new population
+    # Good configuration should in general work without an incest.
+    # Incest can cover up too much mutation
+    incest = 2
+
+
+def main():
+
+    # Display codes
+    print("CODES TO BREAK:", end=' ')
+    for code in codes:
+        print("".join(str(digit) for digit in code), end=' ')
+    print()
+
+    # Display some statistics
+    combinations = 10**(locks * digits_in_lock)
+    operations = 10000 * 10**6
+    print("Theoretical number of combinations", combinations)
+    print("Optimistic operations per second:", operations)
+    print("Direct bruteforce time:", 1.0* combinations / operations / 60.0/60/24, "days")
+
+    # Hack the case.
+    started = time()
+
+    # Create population
+    ph = CodeHackerPopulation()
+
+    i = 0
+    while True:
+        b = ph.best()
+        print("generation %02d: %s best=%s average=%s)" % (
+            i, repr(b), b.get_fitness(), ph.fitness()))
+
+        if b.get_fitness() < 1:
+            #for org in ph:
+            #    print "  ", org
+
+            print("cracked in ", i, "generations and ", time() - started, "seconds")
+            break
+
+        sys.stdout.flush()
+        i += 1
+        ph.gen()
+
+
+if __name__ == '__main__':
+    main()

examples3/demo_config_genome.py

@@ -0,0 +1,138 @@
+#! /usr/bin/env python3
+
+"""
+Example build on the demo_quadratic.py - understand that one first!
+
+Program reads it's genome configuration from a config file (quadratic.ini)
+
+Example config file:
+[x1]
+type = float
+randMin = -100.0
+randMax = 100.0
+mutProb = 0.1
+mutAmt = 0.1
+
+[x2]
+type = int
+randMin = -50
+randMax = 50
+mutProb = 0.2
+mutAmt = 1
+
+[x3]
+alias = x2
+
+[x4]
+type = float
+value = 5.4
+
+One section per gene.
+'type' is necessary - other fields depends on the selected type
+possible types (for current list see pygene/config.py):
+int, int_exchange, float, float_exchange, float_random, float_max, complex
+You can create a genes from previously specified ones using 'alias' field.
+
+There might be available a special section 'population' with parameters
+for population. It's never treated as a gene.
+"""
+
+from pygene3.gene import FloatGene, FloatGeneMax
+from pygene3.organism import Organism, MendelOrganism
+from pygene3.population import Population
+from pygene3.config import ConfigLoader
+
+# parameters for quadratic equation
+# has roots 3 and 5
+if 1:
+    a = 2
+    b = -16
+    c = 30
+else:
+    # this alternate set has only 1 root, x=4
+    a = 2.0
+    b = 3.0
+    c = -44.0
+
+def quad(x):
+    return a * x ** 2 + b * x + c
+
+loader = ConfigLoader(filename="quadratic.ini", require_genes=['x1', 'x2'])
+
+class QuadraticSolver(Organism):
+    """
+    Implements the organism which tries
+    to solve a quadratic equation
+    """
+    genome = loader.load_genome()
+
+    def fitness(self):
+        """
+        Implements the 'fitness function' for this species.
+        Organisms try to evolve to minimise this function's value
+        """
+        x1 = self['x1']
+        x2 = self['x2']
+
+        # this formula punishes for roots being wrong, also for
+        # roots being the same
+        badness_x1 = abs(quad(x1)) # punish for incorrect first root
+        badness_x2 = abs(quad(x2)) # punish for incorrect second root
+        badness_equalroots = 1.0 / (abs(x1 - x2)) # punish for equal roots
+        return badness_x1 + badness_x2 + badness_equalroots
+
+    def __repr__(self):
+        return "<fitness=%f x1=%s x2=%s>" % (
+            self.fitness(), self['x1'], self['x2'])
+
+
+QPopulation = loader.load_population("QPopulation", species=QuadraticSolver)
+
+"""
+class QPopulation(Population):
+
+    species = QuadraticSolver
+    initPopulation = 20
+
+    # cull to this many children after each generation
+    childCull = 20
+
+    # number of children to create after each generation
+    childCount = 50
+
+    mutants = 0.5
+
+# create a new population, with randomly created members
+"""
+
+pop = QPopulation()
+
+
+# now a func to run the population
+def main():
+    from time import time
+    s = time()
+    try:
+        generations = 0
+        while True:
+            # execute a generation
+            pop.gen()
+            generations += 1
+
+            # and dump it out
+            #print [("%.2f %.2f" % (o['x1'], o['x2'])) for o in pop.organisms]
+            best = pop.organisms[0]
+            print("fitness=%f avg=%f x1=%f x2=%f" % (best.get_fitness(), pop.fitness(),
+                                                     best['x1'], best['x2']))
+            if best.get_fitness() < 0.6:
+                break
+
+    except KeyboardInterrupt:
+        pass
+    print("Executed", generations, "generations in", time() - s, "seconds")
+
+
+if __name__ == '__main__':
+    main()
+
+

examples3/demo_converge.py

@@ -0,0 +1,71 @@
+#! /usr/bin/env python3
+
+"""
+Very simple demo in which organisms try to minimise
+the output value of a function
+"""
+
+from pygene3.gene import FloatGene, FloatGeneMax
+from pygene3.organism import Organism, MendelOrganism
+from pygene3.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()
+