darwinning 0.0.1

data/README.md

@@ -0,0 +1,90 @@
+Darwinning
+==========
+A Ruby gem to aid in the use of genetic algorithms.
+
+Examples
+--------
+
+### Fifteen
+
+Here's an dumb example of how you might use Darwinning to solve a pointless problem:
+
+Let's say for some reason you need a set of 3 number that add up to 15.  This is a strange problem to have, but let's solve it anyway.
+
+```ruby
+class Triple < Darwinning::Organism
+
+	@name = "Triple"
+	@genes = [
+			Darwinning::Gene.new("first digit", (0..9)),
+			Darwinning::Gene.new("second digit", (0..9)),
+			Darwinning::Gene.new("third digit", (0..9))
+		]
+
+	def fitness
+		# Try to get the sum of the 3 digits to add up to 15
+		(genotypes.inject{ |sum, x| sum + x } - 15).abs
+	end
+end 
+
+p = Darwinning::Population.new(Triple, 10, 0, 0.1, 100)
+p.evolve
+
+p.best_member.nice_print # prints the member representing the solution
+```
+
+This code declares an organism class that inherits from Darwinning's Organism parent class to represent solutions.  Then we create a population of these solution organisms and evolve the population until a solution meets the fitness threshold or the generation limit is met.
+
+### Cookies
+
+Or let's say you want to find the perfect chocolate chip cookie recipie.  Sure you could ask your grandmother, but why not let a genetic algorithm do all the work for you?  Some baking may be required for this one.
+
+Define a cookie Organism class, generate an initial population, bake a batch of each and have your friends rate each batch.  Use that rating as the fitness value for each recipie and then generate the next generation of cookie recipies.  Repeat until you have optimized the recipie or you are sick from eating too many cookies.
+
+```ruby
+class Cookie < Darwinning::Organism
+
+	@name = "Chocolate Chip Cookie"
+	@genes = [
+			Darwinning::Gene.new("white sugar", (0..1), [], "cup"),
+			Darwinning::Gene.new("brown sugar", (0..1), [], "cup"),
+			Darwinning::Gene.new("flour", (0..3), [], "cup"),
+			Darwinning::Gene.new("eggs", (0..3)),
+			Darwinning::Gene.new("baking powder", (0..2), [], "teaspoon"),
+			Darwinning::Gene.new("salt", (0..2), [], "teaspoon"),
+			Darwinning::Gene.new("butter", (0..2), [], "cup"),
+			Darwinning::Gene.new("vanilla extract", (0..2), [], "teaspoon"),
+			Darwinning::Gene.new("chocolate chips", (0..20), [], "ounce"),
+			Darwinning::Gene.new("oven temp", (300..400), [], "degrees F"),
+			Darwinning::Gene.new("cook time", (5..20), [], "minute")
+		]
+
+end
+
+p = Darwinning::Population.new(Cookie, 10, 5, 0.1, 100, true)
+
+first_gen_ratings = [1.5, 4, 3, 3.5, 2, 1, 1.5, 3, 2.5, 0.5]
+p.set_members_fitness!(first_gen_ratings)
+
+p.make_next_generation!
+
+p.members.each { |m| m.nice_print } # print second generation of cookie recipies
+```
+
+### Binary String Organism
+
+A simple binary string representation of an organism can be easily created thusly:
+
+```ruby
+class BinaryOrganism < Darwinning::Organism
+
+	10.times { |s| @genes << Darwinning::Gene.new("", [0,1]) }
+
+	def fitness
+		# whatever makes sense here
+	end  
+end
+```
+
+## Built by:
+* [Dave Schwantes](https://github.com/dorkrawk "dorkrawk")

data/lib/darwinning.rb

@@ -0,0 +1,8 @@
+require_relative 'darwinning/gene'
+require_relative 'darwinning/organism'
+require_relative 'darwinning/population'
+require_relative 'darwinning/config'
+
+module Darwinning
+	extend Config
+end

data/lib/darwinning/config.rb

@@ -0,0 +1,6 @@
+module Darwinning
+	module Config
+		# crossover mask?
+		# ordered vs weighted fitness
+	end
+end

data/lib/darwinning/gene.rb

@@ -0,0 +1,21 @@
+module Darwinning
+	class Gene
+		attr_accessor :name, :value, :value_range, :invalid_values, :units
+
+		def initialize(name = "", value_range = [], invalid_values = [], units = "")
+
+			@name = name
+			@value_range = value_range.to_a
+			@invalid_values = invalid_values.to_a
+			@units = units
+		end
+
+		def express
+			(@value_range - @invalid_values).sample
+		end
+
+		def is_valid_value?(value)
+			@value_range.include?(value) and not @invalid_values.include?(value)
+		end
+	end
+end

data/lib/darwinning/organism.rb

@@ -0,0 +1,72 @@
+# Found from http://www.railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/
+module ClassLevelInheritableAttributes
+  def self.included(base)
+    base.extend(ClassMethods)    
+  end
+  
+  module ClassMethods
+    def inheritable_attributes(*args)
+      @inheritable_attributes ||= [:inheritable_attributes]
+      @inheritable_attributes += args
+      args.each do |arg|
+        class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
+      end
+      @inheritable_attributes
+    end
+    
+    def inherited(subclass)
+      @inheritable_attributes.each do |inheritable_attribute|
+        instance_var = "@#{inheritable_attribute}"
+        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+      end
+    end
+  end
+end
+
+module Darwinning
+	class Organism
+
+		include ClassLevelInheritableAttributes
+		inheritable_attributes :genes, :name
+		attr_accessor :genotypes, :fitness, :name, :genes
+
+		@genes = []  # Gene instances
+		@name = ""
+
+		def initialize(genotypes = [])
+			#TODO: catch errors if genotype.length != @genotypes.length
+			# catch if genotype[x] is not a valid value for @gene[x]
+
+			if genotypes == []
+				# fill genotypes with expressed Genes
+				@genotypes = self.class.genes.map { |g| g.express } # Gene expressions
+			else
+				@genotypes = genotypes
+			end
+			@fitness = -1
+		end
+
+		# Selects a random genotype from the organism and rexpresses its gene
+		def mutate!
+			random_index = (0..@genotypes.length-1).to_a.sample 
+			@genotypes[random_index] = self.class.genes[random_index].express
+			self
+		end
+
+		def nice_print
+			puts self.class.name == "" ? "[no name]" : self.class.name
+			self.class.genes.to_enum.each_with_index { |g, i| puts "  #{g.name}: #{@genotypes[i]} #{g.units}" }
+			puts "    fitness: #{fitness}"
+		end
+
+		def name
+			self.class.name
+		end
+
+		def genes
+			self.class.genes
+		end
+	end
+end

data/lib/darwinning/population.rb

@@ -0,0 +1,120 @@
+module Darwinning
+
+	class Population
+		attr_accessor :members, :mutation_rate, :generations_limit, :fitness_goal, :organism, :generation
+
+		def initialize(organism, population_size, fitness_goal, mutation_rate = 0.0, generations_limit = 0, manual_fitness = false)
+			@organism = organism
+			@fitness_goal = fitness_goal
+			@mutation_rate = mutation_rate
+			@generations_limit = generations_limit
+			@manual_fitness = manual_fitness
+			@members = []
+			@generation = 0 # initial population is generation 0
+			
+			build_population(population_size)
+		end
+
+		def build_population(population_size)
+			population_size.times do |i|
+				@members << @organism.new 
+			end
+		end
+
+		def evolve
+			until evolution_over?
+				make_next_generation!
+			end
+		end
+
+		def crossover(m1, m2)
+			genotypes1 = []
+			genotypes2 = []
+
+			m1.genotypes.zip(m2.genotypes).each do |g|
+				if m1.genotypes.index(g[0]) % 2 == 0
+					genotypes1 << g[0]
+					genotypes2 << g[1]
+				else 
+					genotypes1 << g[1]
+					genotypes2 << g[0]
+				end
+			end
+
+			[@organism.new(genotypes1), @organism.new(genotypes2)]
+		end
+
+		def sexytimes(m1, m2)
+			crossover(m1, m2)
+		end
+
+		def weighted_select(members)
+			e = 0.01
+			fitness_sum = members.inject(0) { |sum, m| sum + m.fitness }
+
+			weighted_members = members.sort_by { |m| (m.fitness - @fitness_goal).abs }.map { |m| [m, fitness_sum / ((m.fitness - @fitness_goal).abs + e)] }
+		
+			weight_sum = weighted_members.inject(0) { |sum, m| sum + m[1] }
+			pick = (0..weight_sum).to_a.sample
+			
+			weighted_members.reverse! # In order to pop from the end we need the lowest ranked first
+			pick_sum = 0
+
+			until pick_sum > pick do
+				selected_member = weighted_members.pop 
+				pick_sum += selected_member[1]
+			end
+
+			selected_member[0]
+		end
+
+		def mutate!
+			@members.map! { |m|
+				if (0..100).to_a.sample < @mutation_rate*100
+					m.mutate!
+				else
+					m
+				end
+			}
+		end
+
+		def set_members_fitness!(fitness_values)
+			@members.to_enum.each_with_index { |m, i| m.fitness = fitness_values[i] }
+		end
+
+		def make_next_generation!			
+			temp_members = @members
+			used_members = []
+			new_members = []
+
+			until new_members.length == @members.length/2
+				m1 = weighted_select(@members - used_members)
+				used_members << m1
+				m2 = weighted_select(@members - used_members)
+				used_members << m2
+
+				new_members << crossover(m1,m2)
+			end
+
+			new_members.flatten!
+
+			@members = new_members
+
+			mutate!
+			@generation += 1
+		end
+
+		def evolution_over?
+			# check if the fiteness goal or generation limit has been met
+			@generation == @generations_limit or best_member.fitness == @fitness_goal
+		end
+
+		def best_member
+			@members.sort_by { |m| m.fitness }[0]
+		end
+
+		def size
+			@members.length
+		end
+	end
+end

data/lib/darwinning/version.rb

@@ -0,0 +1,3 @@
+module Darwinning
+  VERSION = "0.0.1"
+end

data/test/darwinning_spec.rb

@@ -0,0 +1,90 @@
+require 'darwinning'
+
+describe Darwinning::Gene do
+	before do 
+		@digit = Darwinning::Gene.new("digit", (0..9))
+		@day_hour = Darwinning::Gene.new("hour", (0..23), [0,1,2,3,4,20,21,22,23], "o'clock")
+	end
+
+	it "name should be set" do
+		@digit.name.should == "digit"
+	end
+
+	it "value range should be set" do
+		@digit.value_range.should == (0..9).to_a
+	end
+
+	it "invalid values should be set" do
+		@day_hour.invalid_values.should == [0,1,2,3,4,20,21,22,23]
+	end
+
+	it "units should be set" do
+		@day_hour.units.should == "o'clock"
+	end
+
+	describe "#express" do
+
+		it "expressed value should be within range" do
+			(0..9).to_a.include?(@digit.express).should == true  # uncertain test
+		end
+
+		it "expressed value should not be invalid value" do
+			@day_hour.invalid_values.include?(@digit.express).should == false # uncertain test
+		end
+	end
+
+end
+
+describe Darwinning::Organism do
+	before do
+		@org = Darwinning::Organism.new
+
+		class Triple < Darwinning::Organism
+			@name = "Triple"
+			@genes = [
+					Darwinning::Gene.new("first digit", (0..9)),
+					Darwinning::Gene.new("second digit", (0..9)),
+					Darwinning::Gene.new("third digit", (0..9))
+				]
+
+			def fitness
+				# Try to get the sum of the 3 digits to add up to 15
+				(genotypes.inject{ |sum, x| sum + x } - 15).abs
+			end
+		end
+		@triple = Triple.new
+	end
+
+	it "name should default to blank" do
+		@org.name.should == ""
+	end
+
+	it "genes should default to empty array" do
+		@org.genes.should == []
+	end
+
+	it "genotypes should initialize to empty array if genes is empty" do
+		@org.genotypes.should == []
+	end
+
+	it "fitness should default to -1" do
+		@org.fitness.should == -1
+	end
+
+	it "child class should set name" do
+		@triple.name.should == "Triple"
+	end
+
+	it "child class should set genes" do
+		@triple.genes.length.should == 3 # not the best test...
+	end
+
+	it "child class should initialize genotypes from genes" do
+		@triple.genotypes.length.should == 3 # not the best test...
+	end
+
+end
+
+describe Darwinning::Population do
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: darwinning
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Dave Schwantes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-23 00:00:00.000000000 Z
+dependencies: []
+description: Darwinning provides tools to build genetic algorithm solutions using
+  a Gene, Organism, and Population structure.
+email: dave.schwantes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/darwinning/config.rb
+- lib/darwinning/gene.rb
+- lib/darwinning/organism.rb
+- lib/darwinning/population.rb
+- lib/darwinning/version.rb
+- lib/darwinning.rb
+- Rakefile
+- README.md
+- test/darwinning_spec.rb
+homepage: https://github.com/dorkrawk/darwinning
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Ruby gem to aid in the use of genetic algorithms.
+test_files:
+- test/darwinning_spec.rb