evosynth 0.1.0

data/examples/ccga_example.rb

@@ -0,0 +1,150 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	Permission is hereby granted, free of charge, to any person
+#	obtaining a copy of this software and associated documentation
+#	files (the "Software"), to deal in the Software without
+#	restriction, including without limitation the rights to use,
+#	copy, modify, merge, publish, distribute, sublicense, and/or sell
+#	copies of the Software, and to permit persons to whom the
+#	Software is furnished to do so, subject to the following
+#	conditions:
+#
+#	The above copyright notice and this permission notice shall be
+#	included in all copies or substantial portions of the Software.
+#
+#	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+#	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+#	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+#	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#	OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'evosynth'
+#require 'profile'
+
+
+module Examples
+
+	# This example is EvoSynth's interpretation of DeJong and Potter's CCGA presented in
+	# "A Cooperative Coevolutionary Approach to Function Optimization" (1994)
+
+	module CCGAExample
+
+		VALUE_BITS = 16
+		DIMENSIONS = 5
+		MAX_EVALUATIONS = 25000
+		POPULATION_SIZE = 25
+
+		def CCGAExample.fitness_function(xs)
+			EvoSynth::Problems::FloatBenchmarkFuntions.rosenbrock(xs)
+		end
+
+		class CCGABenchmarkEvaluator < EvoSynth::Evaluator
+
+			def initialize(populations)
+				super()
+				@populations = populations
+			end
+
+			def decode(individual, random = false)
+				values = (0..DIMENSIONS-1).to_a
+				values.each do |index|
+					to_decode = if index == individual.population_index
+						individual.genome
+					elsif random
+						@populations[index][EvoSynth.rand(@populations[index].size)].genome
+					else
+						@populations[index].best.genome
+					end
+
+					values[index] = EvoSynth::Decoder.binary_to_real(to_decode, -5.12, 5.12)
+				end
+				values
+			end
+
+			def calculate_fitness(individual)
+				CCGAExample.fitness_function(decode(individual))
+			end
+
+		end
+
+		class CCGA2BenchmarkEvaluator < CCGABenchmarkEvaluator
+
+			def calculate_fitness(individual)
+				best_individual = CCGAExample.fitness_function(decode(individual))
+				rand_individual = CCGAExample.fitness_function(decode(individual, true))
+
+				individual.compare_fitness_values(best_individual, rand_individual) == 1 ? best_individual : rand_individual
+			end
+
+		end
+
+		class CCGAIndividual < EvoSynth::MinimizingIndividual
+			attr_accessor :population_index
+
+			def initialize(population_index, *args)
+				@population_index = population_index
+				super(*args)
+			end
+		end
+
+		def CCGAExample.create_profile(evaluator)
+			populations = []
+			DIMENSIONS.times do |dim|
+				populations << EvoSynth::Population.new(POPULATION_SIZE) { CCGAIndividual.new(dim, EvoSynth::ArrayGenome.new(VALUE_BITS) { EvoSynth.rand_bool }) }
+			end
+
+			EvoSynth::Profile.new(
+				:mutation					=> EvoSynth::Mutations::BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN),
+				:parent_selection			=> EvoSynth::Selections::FitnessProportionalSelection.new,
+				:recombination				=> EvoSynth::Recombinations::KPointCrossover.new(2),
+				:recombination_probability	=> 0.6,
+				:populations				=> populations,
+				:evaluator					=> evaluator.new(populations)
+			)
+		end
+
+		def CCGAExample.run(evolver, profile, evolver_name)
+			evolver.add_observer(EvoSynth::Output.create_console_logger(50,
+				"generations" => ->{ evolver.generations_computed },
+				"evaluations" => ->{ profile.evaluator.called },
+				"fitness"     => ->{ best_genome = [];
+									 evolver.best_solution.each { |individual| best_genome <<  EvoSynth::Decoder.binary_to_real(individual.genome, -5.12, 5.12) };
+									 CCGAExample.fitness_function(best_genome)
+									}
+			))
+
+			puts "\nRunning #{evolver}..."
+			puts
+			result = evolver.run_until { profile.evaluator.called < MAX_EVALUATIONS }
+			puts "\n#{profile.evaluator}"
+
+			puts "\n#{evolver_name}: best 'combined' individual:"
+			best = []
+			result.each { |pop| best << pop.best; puts "\t#{pop.best}" }
+
+			best_genome = []
+			best.each { |individual| best_genome <<  EvoSynth::Decoder.binary_to_real(individual.genome, -5.12, 5.12) }
+
+			puts "\n#{evolver_name}: best 'combined' genome:"
+			puts "\t#{best_genome.inspect}"
+			puts "\n\tfitness = #{CCGAExample.fitness_function(best_genome)}"
+			puts
+		end
+
+		puts "# --- CCGA-1 ----------------------------------------------------------------------------------- #"
+
+		profile = create_profile(CCGABenchmarkEvaluator)
+		evolver = EvoSynth::Evolvers::RoundRobinCoevolutionary.new(profile)
+		run(evolver, profile, "CCGA-1")
+
+		puts "# --- CCGA-2 ----------------------------------------------------------------------------------- #"
+
+		profile = create_profile(CCGA2BenchmarkEvaluator)
+		evolver = EvoSynth::Evolvers::RoundRobinCoevolutionary.new(profile)
+		run(evolver, profile, "CCGA-2")
+	end
+end

data/examples/cmb_example.rb

@@ -0,0 +1,117 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	Permission is hereby granted, free of charge, to any person
+#	obtaining a copy of this software and associated documentation
+#	files (the "Software"), to deal in the Software without
+#	restriction, including without limitation the rights to use,
+#	copy, modify, merge, publish, distribute, sublicense, and/or sell
+#	copies of the Software, and to permit persons to whom the
+#	Software is furnished to do so, subject to the following
+#	conditions:
+#
+#	The above copyright notice and this permission notice shall be
+#	included in all copies or substantial portions of the Software.
+#
+#	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+#	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+#	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+#	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#	OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'evosynth'
+
+
+module Examples
+
+	# This example is based on "Coevolution, Memory and Balance" from Paredis, 1999
+
+	module CMBExample
+
+		GENOME_SIZE = 32
+		NUM_PEAKS = 8
+		MAX_GENERATIONS = 2000
+		SOLUTIONS = 25
+		PROBLEMS = 25
+
+		class CMBEvaluator < EvoSynth::Evaluator
+			# TODO: move this into superclass (Evaluator) - maybe use a special evaluator?
+
+			def toggle(result)
+				1.0 - result
+			end
+
+			# sets fitnesses and returns winner
+
+			def encounter(problem, solution, set_problem_fitness = true, set_solution_fitness = true)
+				result = EvoSynth::Problems::BinaryBenchmarkFuntions.n_peaks(problem.genome, solution.genome)
+
+				solution.fitness = result if set_problem_fitness
+				problem.fitness = toggle(result) if set_solution_fitness
+
+				# TODO: dirty hack - think about proper solution
+				@calculated += 1
+				@called += 1
+
+				solution.fitness > 0.5 ? solution : problem
+			end
+		end
+
+		class EvoSynth::Individual
+			# TODO: put this in a good place :)
+
+			def initialize
+				@memory = []
+				@memory_size = 1
+			end
+
+			def fitness=(value)
+				if @memory.empty?
+					@memory = [value] * @memory_size
+				else
+					@memory.pop
+					@memory << value
+				end
+			end
+
+			def fitness
+				sum = @memory.inject(0.0) { |sum, value| sum += value }
+				sum / @memory_size
+			end
+
+		end
+
+
+		def CMBExample.generate_problem(peak_count)
+			peaks = []
+			peak_count.times do
+				peak = []
+				GENOME_SIZE.times { peak << EvoSynth.rand_bool }
+				peaks << peak
+			end
+			EvoSynth::ArrayGenome.new(peaks)
+		end
+
+
+		profile = EvoSynth::Profile.new(
+			:mutation					=> EvoSynth::Mutations::BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN),
+			:problem_mutation			=> EvoSynth::Mutations::MixingMutation.new,
+			:problem_recombination		=> EvoSynth::Recombinations::OnePointCrossover.new,
+			:population					=> EvoSynth::Population.new(SOLUTIONS) { EvoSynth::MaximizingIndividual.new( EvoSynth::ArrayGenome.new(GENOME_SIZE) { EvoSynth.rand_bool } ) },
+			:problems					=> EvoSynth::Population.new(PROBLEMS) { EvoSynth::MaximizingIndividual.new( CMBExample.generate_problem(NUM_PEAKS) ) },
+			:evaluator					=> CMBEvaluator.new
+		)
+
+		evolver = EvoSynth::Evolvers::BalancedCoevolutionary.new(profile)
+		evolver.add_observer(EvoSynth::Output.create_console_logger(25,
+			"generations"				=> ->{ evolver.generations_computed },
+			"best solution fitness"		=> ->{ evolver.population.best.fitness },
+			"best problem fitness"		=> ->{ evolver.problems.best.fitness },
+			"solution_success"			=> ->{ evolver.solution_success }
+		))
+		evolver.run_until_generations_reached(MAX_GENERATIONS)
+	end
+end

data/examples/evolution_strategies.rb

@@ -0,0 +1,84 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	Permission is hereby granted, free of charge, to any person
+#	obtaining a copy of this software and associated documentation
+#	files (the "Software"), to deal in the Software without
+#	restriction, including without limitation the rights to use,
+#	copy, modify, merge, publish, distribute, sublicense, and/or sell
+#	copies of the Software, and to permit persons to whom the
+#	Software is furnished to do so, subject to the following
+#	conditions:
+#
+#	The above copyright notice and this permission notice shall be
+#	included in all copies or substantial portions of the Software.
+#
+#	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+#	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+#	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+#	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#	OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'evosynth'
+#require 'profile'
+
+
+module Examples
+	module EsExample
+
+		DIMENSIONS = 5
+		GENERATIONS = 500
+		POPULATION_SIZE = 25
+
+		def EsExample.fitness_function(xs)
+			EvoSynth::Problems::FloatBenchmarkFuntions.sphere(xs)
+		end
+
+		class BenchmarkEvaluator < EvoSynth::Evaluator
+			def calculate_fitness(individual)
+				EsExample.fitness_function(individual.genome)
+			end
+		end
+
+		def EsExample.create_individual(genome_size)
+			individual = EvoSynth::MinimizingIndividual.new
+			individual.genome = EvoSynth::ArrayGenome.new(genome_size) { EvoSynth.rand * 10.24 - 5.12 }
+			individual
+		end
+
+		def EsExample.run(evolver_class, profile, base_population)
+			profile.evaluator.reset_counters
+			profile.population = base_population.deep_clone
+			evolver = evolver_class.new(profile)
+
+			evolver.add_observer(EvoSynth::Output.create_console_logger(50,
+				"generations"	=> ->{ evolver.generations_computed },
+				"bestfitness"   => ->{ evolver.best_solution.fitness },
+				"worstfitness"  => ->{ evolver.worst_solution.fitness },
+				"sigma"			=> ->{ evolver.sigma },
+				"success"	    => ->{ evolver.success },
+				"s"				=> ->{ evolver.s.inspect }
+			))
+
+			puts "\nRunning #{evolver}...\n"
+			result = evolver.run_until_generations_reached(GENERATIONS)
+			puts "", profile.evaluator
+			puts "\nfitness = #{profile.evaluator.calculate_fitness(result.best)}"
+			puts
+		end
+
+		base_population = EvoSynth::Population.new(POPULATION_SIZE) { EsExample.create_individual(DIMENSIONS) }
+		profile = EvoSynth::Profile.new(
+			:modification_frequency => 10,
+			:evaluator				=> BenchmarkEvaluator.new,
+			:tau					=> 1 / Math.sqrt(DIMENSIONS)
+		)
+
+		EsExample.run(EvoSynth::Evolvers::AdaptiveES, profile, base_population)
+		EsExample.run(EvoSynth::Evolvers::SelfAdaptiveES, profile, base_population)
+		EsExample.run(EvoSynth::Evolvers::DerandomizedES, profile, base_population)
+	end
+end

data/examples/exporter.rb

@@ -0,0 +1,90 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	Permission is hereby granted, free of charge, to any person
+#	obtaining a copy of this software and associated documentation
+#	files (the "Software"), to deal in the Software without
+#	restriction, including without limitation the rights to use,
+#	copy, modify, merge, publish, distribute, sublicense, and/or sell
+#	copies of the Software, and to permit persons to whom the
+#	Software is furnished to do so, subject to the following
+#	conditions:
+#
+#	The above copyright notice and this permission notice shall be
+#	included in all copies or substantial portions of the Software.
+#
+#	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+#	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+#	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+#	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#	OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'evosynth'
+#require 'profile'
+
+
+module Examples
+	module Exporter
+
+		VALUE_BITS = 16
+		DIMENSIONS = 6
+		POP_SIZE = 25
+		GENERATIONS = 100
+		GENOME_SIZE = VALUE_BITS * DIMENSIONS
+
+		class ExporterEvaluator < EvoSynth::Evaluator
+			def decode(individual)
+				values = []
+				DIMENSIONS.times { |dim| values << EvoSynth::Decoder.binary_to_real(individual.genome[dim * VALUE_BITS, VALUE_BITS], -5.12, 5.12) }
+				values
+			end
+
+			def calculate_fitness(individual)
+				EvoSynth::Problems::FloatBenchmarkFuntions.rastgrin(decode(individual))
+			end
+		end
+
+		def Exporter.create_individual(genome_size)
+			EvoSynth::MinimizingIndividual.new( EvoSynth::ArrayGenome.new(genome_size) { EvoSynth.rand_bool } )
+		end
+
+		evaluator = ExporterEvaluator.new
+		profile = EvoSynth::Profile.new(
+			:mutation			=> EvoSynth::Mutations::BinaryMutation.new(EvoSynth::Mutations::Functions::FLIP_BOOLEAN),
+			:parent_selection	=> EvoSynth::Selections::FitnessProportionalSelection.new,
+			:recombination		=> EvoSynth::Recombinations::KPointCrossover.new(2),
+			:population			=> EvoSynth::Population.new(POP_SIZE) { Exporter.create_individual(GENOME_SIZE) },
+			:evaluator			=> evaluator
+		)
+
+		evolver = EvoSynth::Evolvers::GeneticAlgorithm.new(profile)
+		EvoSynth::Evolvers.add_strong_elistism(evolver)
+		evolver.add_observer(EvoSynth::Output.create_console_logger(10,
+			"gen" => ->{ evolver.generations_computed },
+			"best" => ->{ profile.population.best.fitness },
+			"worst" => ->{ profile.population.worst.fitness }
+		))
+
+		plot_logger = EvoSynth::Output::Logger.new(5, true,
+			"best fitness" => ->{ profile.population.best.fitness },
+#			"foo" => ->{ evolver.generations_computed },
+#			"bar" => ->{ 100 - evolver.generations_computed },
+			"worst fitness" => ->{ profile.population.worst.fitness }
+		)
+		evolver.add_observer(plot_logger)
+#		evaluator.add_observer(plot_logger)
+		evolver.run_until_generations_reached(GENERATIONS)
+		BASEPATH = File.expand_path(".")
+
+		puts "\nexport to gnuplot..."
+		EvoSynth::Output::GnuPlotExporter.new(plot_logger).export("Rastgrin function with Elistism GA")
+		puts "export with gruff to #{BASEPATH + '/evosynth_viz_gruff.png'}..."
+		EvoSynth::Output::GruffExporter.new(plot_logger).export("Rastgrin function with Elistism GA", BASEPATH + '/evosynth_viz_gruff.png')
+		puts "export a CSV-File to #{BASEPATH + '/evosynth_export.csv'}..."
+		EvoSynth::Output::CSVExporter.new(plot_logger, true).export(BASEPATH + '/evosynth_export.csv')
+
+	end
+end

data/examples/graph_colouring.rb

@@ -0,0 +1,72 @@
+#	Copyright (c) 2009, 2010 Yves Adler <yves.adler@googlemail.com>
+#
+#	Permission is hereby granted, free of charge, to any person
+#	obtaining a copy of this software and associated documentation
+#	files (the "Software"), to deal in the Software without
+#	restriction, including without limitation the rights to use,
+#	copy, modify, merge, publish, distribute, sublicense, and/or sell
+#	copies of the Software, and to permit persons to whom the
+#	Software is furnished to do so, subject to the following
+#	conditions:
+#
+#	The above copyright notice and this permission notice shall be
+#	included in all copies or substantial portions of the Software.
+#
+#	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+#	OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+#	HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+#	WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+#	FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+#	OTHER DEALINGS IN THE SOFTWARE.
+
+
+require 'evosynth'
+
+
+module Examples
+	module GraphColouring
+
+		MAX_COLORS = 10
+		GENERATIONS = 10000
+		INDIVIDUALS = 10
+		GOAL = 5
+		FLIP_GRAPH_COLOUR = lambda { |gene| EvoSynth.rand(gene + 2) }
+
+		def GraphColouring.create_random_individual(graph_evaluator)
+			genome = EvoSynth::ArrayGenome.new(graph_evaluator.node_count)
+			max_color = EvoSynth.rand(genome.size > MAX_COLORS ? MAX_COLORS : genome.size) + 1
+			genome.map! { |gene| EvoSynth.rand(max_color)}
+			genome.map! { |gene| gene % genome.uniq.size }
+			inidividual = EvoSynth::MinimizingIndividual.new(genome)
+			inidividual
+		end
+
+		graph_evaluator = nil
+		begin
+			graph_evaluator = EvoSynth::Problems::GraphColouring.new("testdata/myciel4.col")
+		rescue
+			puts "Could not load test data. Please see testdata/README for instructions..."
+			exit(0)
+		end
+
+		profile = EvoSynth::Profile.new(
+			:mutation			=> EvoSynth::Mutations::BinaryMutation.new(FLIP_GRAPH_COLOUR, 0.01),
+			:parent_selection	=> EvoSynth::Selections::RouletteWheelSelection.new,
+			:recombination		=> EvoSynth::Recombinations::KPointCrossover.new,
+			:population			=> EvoSynth::Population.new(INDIVIDUALS) { GraphColouring.create_random_individual(graph_evaluator) },
+			:evaluator			=> graph_evaluator
+		)
+
+		evolver = EvoSynth::Evolvers::SteadyStateGA.new(profile)
+		evolver.add_observer(EvoSynth::Output.create_console_logger(500,
+			"generations"	=> ->{ evolver.generations_computed },
+			"bestfitness"   => ->{ evolver.best_solution.fitness },
+			"worstfitness"  => ->{ evolver.worst_solution.fitness }
+		))
+
+		evolver.run_until { |gen, best| best.fitness <= GOAL || gen > GENERATIONS }
+		puts "", profile.population.best
+	end
+end