genetic_framework 0.0.1

data/genetic.rb

@@ -0,0 +1,136 @@
+class Array
+    
+    def random_element
+        self[Random.rand(self.size)]
+    end
+end
+
+class GenePool
+#TODO: Elite children, custom crossover point (min point at which cross begins)    
+    class Spawn
+        
+        attr_reader :string, :fitness
+        
+        def initialize(fitness, string)
+            @fitness = fitness
+            @string = string        
+        end
+        
+        def <=>(other)
+            return self.fitness <=> other.fitness
+        end
+        
+    end
+
+    def initialize(gen_size, encoding_map, mutation_prob, cull_threshold = nil, elite = 0, initial_gen = nil, &fitness)
+        @gen_size = gen_size
+        @encoding_map = encoding_map
+        @mutation_prob = mutation_prob
+        @cull_threshold = cull_threshold
+        @elite = elite
+        @fitness = fitness
+        if !initial_gen
+            @gen = initialize_gen.map {|str| Spawn.new(yield(str), str)}
+        end
+    end
+    
+    attr_accessor :gen_size, :cull_threshold, :mutation_prob, :elite
+    attr_reader :gen, :encoding_map
+    
+    private
+    
+    #creates a string encoding based on the character map
+    #randomly selects a char for each position
+    def build_spawn
+        spawn = []
+        @encoding_map.each do |position|
+            spawn << position.random_element
+        end
+        return spawn.join
+    end
+
+    #char_map should be an array with length identical to string encoding length
+    #and each position contains a list of chars possible for that position
+    def initialize_gen
+        pop = []
+        1.upto(@gen_size) do |spawn_num|
+            pop << build_spawn
+        end
+        return pop
+    end
+
+
+    def random_sexual_selection
+        selected = []
+        candidates = []
+        
+        #create a list of candidates who meet the requirements (all if there is no cull)
+        #a candidate shows up in the list once for each fitness level. This may be memory heavy,
+        #so TODO improve the selection based on fitness
+        strong = @gen.select {|spawn| !@cull_threshold or spawn.fitness >= @cull_threshold}
+        if strong.uniq.size < 2
+            pool = @gen
+        else
+            pool = strong
+        end
+        pool.each do |candidate|
+            1.upto(candidate.fitness + 1) do #if this is 0, you have significant problems without the +1
+                candidates << candidate
+            end
+        end
+        
+        #select from amount candidates a generation_size number of parents. Candidates can be selected
+        #more than once, and have a higher chance of being selected for a higher fitness score
+        1.upto(@gen_size) do
+            selected << candidates.random_element
+        end
+        return selected
+    end
+
+    #mates two parent strings to create two child strings
+    def sexually_reproduce(parent1, parent2)
+        crossover = Random.rand(parent1.size)
+        child1 = parent1[0, crossover] + parent2[crossover, parent2.size]
+        child2 = parent2[0, crossover] + parent1[crossover, parent2.size]
+        return [child1, child2]
+    end
+
+    def mutate(string)
+       0.upto(string.size - 1) do |str_index|
+           if Random.rand < @mutation_prob
+               string[str_index] = @encoding_map[str_index].random_element
+           end
+       end
+       return string
+    end
+
+    public
+    
+    #takes generation and evolves it one generation. if generation is nil, returns an initial, random generation
+    #the char_map is a list of lists - each position has a list of chars that are valid for that position.
+    #it tells us both how long each string is and what sort of encodings are valid for creation.
+    #Resulting generation is sorted according to fitness from least to greatest.
+    def evolve
+        #select spawn who will breed
+        parents = random_sexual_selection
+        #generation size should be even... or the last parent selected will be ignored
+        #breed new spawn
+        new_gen = []
+        
+        if @elite
+            1.upto(@elite) do |offset|
+                if offset > @gen.size then break end
+                new_gen << @gen[-offset]
+            end
+        end
+        start_count = new_gen.size
+        (start_count..@gen_size - 1).step(2) do |index|
+            new_gen += sexually_reproduce(parents[index].string, parents[index + 1].string).map do |child_string| 
+                s = mutate(child_string)
+                Spawn.new(@fitness.call(s), s)
+            end
+        end
+        
+        @gen = new_gen.sort
+    end    
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: genetic_framework
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Brian Fults
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-06 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: 
+- xclite@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- genetic.rb
+has_rdoc: true
+homepage: https://github.com/xclite/genetic_framework
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Facilitates use of genetic evolution to find a solution to a defined problem.
+test_files: []
+