New example: demo_case.py

Shows why genetic algorithms works.

Few fixes in organism code.

Author: Tomasz bla Fortuna

demo_case.py

@@ -0,0 +1,163 @@
+#! /usr/bin/env python
+"""
+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 pygene.gene import IntGene, IntGeneRandom, IntGeneExchange
+from pygene.organism import Organism, GenomeSplitOrganism
+from pygene.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):
+
+    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:",
+    for code in codes:
+        print "".join(str(digit) for digit in code),
+    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()

demo_string.py

@@ -74,7 +74,7 @@ class StringHackerPopulation(Population):
     childCull = 10
 
     # number of children to create after each generation
-    childCount = 50
+    childCount = 100
 
     mutants = 0.25
 

pygene/gene.py

@@ -279,6 +279,7 @@ def mutate(self):
         """
         self.value = self.randomValue()
 
+
 class FloatGeneRandRange(FloatGene):
     def __add__(self, other):
         """
@@ -367,6 +368,19 @@ def __add__(self, other):
         return max(self.value, other.value)
 
 
+class IntGeneRandom(IntGene):
+    """
+    Variant of IntGene where mutation always randomises the value
+    """
+    def mutate(self):
+        """
+        Randomise the gene
+
+        perform mutation IN-PLACE, ie don't return mutated copy
+        """
+        self.value = self.randomValue()
+
+
 class IntGeneExchange(IntGene):
     def __add__(self, other):
         """

pygene/organism.py

@@ -16,7 +16,7 @@
 programming.
 """
 
-from random import random, randrange, choice
+from random import random, randrange, randint, choice
 
 from gene import BaseGene, rndPair
 from gamete import Gamete
@@ -418,8 +418,7 @@ def mate(self, partner):
         # g.g.g.g.g.g
         #           ^-  split in 5:
         # G.G.G.G.G.G
-        intersection = randrange(0, len(self.genome))
-
+        intersection = randint(0, len(self.genome))
         # gene by gene, we assign our and partner's genes randomly
         for i, name in enumerate(sorted(self.genome.keys())):
             cls = self.genome[name]
@@ -443,7 +442,6 @@ def mate(self, partner):
         # got the genotypes, now create the child organisms
         child1 = self.__class__(**genotype1)
         child2 = self.__class__(**genotype2)
-
         return (child1, child2)
 
 class MendelOrganism(BaseOrganism):

pygene/population.py

@@ -231,7 +231,6 @@ def gen(self, nfittest=None, nchildren=None):
 
             children.extend([child1, child2])
 
-
         # if incestuous, add in best adults
         if self.incest:
             children.extend(self[:self.incest])
@@ -269,9 +268,7 @@ def gen(self, nfittest=None, nchildren=None):
             children.extend(mutants)
             children.sort()
         #print "added %s mutants" % numMutants
-
         # sort the children by fitness
-
         # take the best 'nfittest', make them the new population
         self.organisms[:] = children[:nfittest]