evoasm 0.0.2.pre7 → 0.1.0.pre2

data/lib/evoasm/parameter.rb

@@ -0,0 +1,20 @@
+require 'evoasm/domain'
+
+module Evoasm
+  # Base class for all parameters.
+  class Parameter < FFI::Pointer
+
+    # @return [Integer] a numeric identifier for this parameter
+    def id
+      Libevoasm.param_get_id self
+    end
+
+    # @return [Domain] the domain associated with this parameter
+    def domain
+      domain = Domain.wrap Libevoasm.param_get_domain(self)
+      domain.autorelease = false
+
+      domain
+    end
+  end
+end

data/lib/evoasm/population.rb

@@ -0,0 +1,145 @@
+require 'evoasm/error'
+require 'ffi'
+
+module Evoasm
+  class Population < FFI::AutoPointer
+
+    # @return [Population::Parameters] population parameters
+    attr_reader :parameters
+
+    # @!visibility private
+    def self.release(ptr)
+      Libevoasm.pop_destroy(ptr)
+      Libevoasm.pop_free(ptr)
+    end
+
+    # @param parameters [Population::Parameters] the population parameters
+    # @param architecture [Symbol] architecture, currently only +:x64+ is supported
+    def initialize(parameters, architecture = Evoasm.architecture)
+      @parameters = parameters
+
+      ptr = Libevoasm.pop_alloc
+      unless Libevoasm.pop_init ptr, architecture, @parameters
+        raise Error.last
+      end
+
+      super(ptr)
+    end
+
+    # Evaluates all programs and kernels in the population
+    # @return [void]
+    def evaluate
+      unless Libevoasm.pop_eval self
+        raise Error.last
+      end
+    end
+
+    # Seeds the population with random individuals
+    # @return [void]
+    def seed
+      Libevoasm.pop_seed self
+    end
+
+    # @return [Float] the loss of the best program found so far
+    # @see #best_program
+    def best_loss
+      Libevoasm.pop_get_best_loss self
+    end
+
+    # @return [Program] the best program found so far
+    def best_program
+      program = Program.new
+      unless Libevoasm.pop_load_best_program self, program
+        raise Error.last
+      end
+
+      program
+    end
+
+    # @!visibility private
+    def loss_samples
+      Array.new(@parameters.deme_count) do |deme_index|
+        data_ptr_ptr = FFI::MemoryPointer.new :pointer, 1
+        len = Libevoasm.pop_get_loss_samples self, deme_index, data_ptr_ptr
+        data_ptr = data_ptr_ptr.read_pointer
+        data_ptr.read_array_of_float len
+      end
+    end
+
+    # Gives a five-number summary for each deme, program and kernel.
+    # @return [Array] a 2-dimensional array of summaries.
+    def summary(flat: false)
+      summary_len = Libevoasm.pop_summary_len self
+      summary_ptr = FFI::MemoryPointer.new :float, summary_len
+      unless Libevoasm.pop_calc_summary self, summary_ptr
+        raise Error.last
+      end
+
+      summary = summary_ptr.read_array_of_float(summary_len).each_slice(summary_len / @parameters.deme_count).to_a
+      unless flat
+        summary.map!{|deme_summary| deme_summary.each_slice(5).to_a}
+      end
+
+      summary
+    end
+
+    # Execute a single generational cycle
+    # @return [void]
+    def next_generation!
+      Libevoasm.pop_next_gen self
+    end
+
+    # Stops the process started by {#run}
+    # @return [void]
+    def stop
+      @stop = true
+    end
+
+    # Plots the loss function
+    # @return [void]
+    def plot(filename = nil)
+      @plotter ||= Plotter.new self, filename
+      @plotter.update
+      @plotter.plot
+    end
+
+    # Starts the evolutionary process on this population
+    # @param loss [Float] stop process if a program is found whose loss is less or equal than the specified loss
+    # @param min_generations [Integer] minimum number of generations to run
+    # @param max_generations [Integer] maximum number of generations to run
+    # @param seed [Bool] whether the population should be seeded before starting
+    # @yield [self]
+    # @yieldreturn a truthy value to stop the process
+    # @return [Program] the best program found
+
+    def run(loss: nil, min_generations: nil, max_generations: 10, seed: true, &block)
+      self.seed if seed
+      best_program = nil
+      best_loss = nil
+      generation = 1
+
+      loop do
+        evaluate
+
+        best_program = self.best_program
+        best_loss = self.best_loss
+
+        block[self]
+
+        break if @stop
+        min_generations_reached = min_generations.nil? || generation >= min_generations
+        break if min_generations_reached && loss && best_loss <= loss
+        break if generation >= max_generations
+
+        next_generation!
+        generation += 1
+      end
+
+      @stop = false
+      return best_program, best_loss
+    end
+  end
+end
+
+require 'evoasm/population/parameters'
+require 'evoasm/population/plotter'

data/lib/evoasm/population/parameters.rb

@@ -0,0 +1,227 @@
+require 'evoasm/prng'
+require 'evoasm/program/io'
+require 'evoasm/domain'
+
+module Evoasm
+  class Population
+
+    class Parameters < FFI::AutoPointer
+
+      # @!visibility private
+      def self.release(ptr)
+        Libevoasm.pop_params_free ptr
+      end
+
+      # @return [Program::Input] input examples
+      attr_reader :input
+
+      # @return [Program::Output] output examples
+      attr_reader :output
+
+      # @param architecture [Symbol] the machine architecture (currently only +:x64+ is supported)
+      # @yield [self]
+      def initialize(architecture = Evoasm.architecture, &block)
+        ptr = Libevoasm.pop_params_alloc
+        Libevoasm.pop_params_init ptr
+
+        case architecture
+        when :x64
+          @inst_id_enum_type = Libevoasm.enum_type :x64_inst_id
+          @param_id_enum_type = Libevoasm.enum_type :x64_param_id
+        else
+          raise "unknown architecture #{architecture}"
+        end
+
+        super(ptr)
+
+        self.seed = PRNG::DEFAULT_SEED
+
+        if block
+          block[self]
+        end
+      end
+
+      # @!attribute mutation_rate
+      # @return [Float 0..1] the mutation rate
+      def mutation_rate
+        Libevoasm.pop_params_get_mut_rate(self)
+      end
+
+      def mutation_rate=(mutation_rate)
+        Libevoasm.pop_params_set_mut_rate self, mutation_rate
+      end
+
+      # @!attribute deme_size
+      # @return [Integer] the number of individuals per deme
+      def deme_size
+        Libevoasm.pop_params_get_deme_size self
+      end
+
+      def deme_size=(deme_size)
+        Libevoasm.pop_params_set_deme_size self, deme_size
+      end
+
+      # @!attribute deme_count
+      # @return [Integer] the number of demes in the population
+      def deme_count
+        Libevoasm.pop_params_get_n_demes self
+      end
+
+      def deme_count=(deme_count)
+        Libevoasm.pop_params_set_n_demes self, deme_count
+      end
+
+      # @!attribute parameters
+      # @return [Array<Symbol>] the list of architecture-dependent instruction parameters to use
+      def parameters
+        Array.new(Libevoasm.pop_params_get_n_params self) do |index|
+          parameters_enum_type[Libevoasm.pop_params_get_param(self, index)]
+        end
+      end
+
+      def parameters=(parameter_names)
+        parameter_names.each_with_index do |parameter_name, index|
+          Libevoasm.pop_params_set_param(self, index, parameters_enum_type[parameter_name])
+        end
+        Libevoasm.pop_params_set_n_params(self, parameter_names.size)
+      end
+
+      # @!attribute domains
+      # @return [Hash{Symbol => Array, Range}] a hash whose values indicate user-defined domains for the parameters given as keys
+      def domains
+        parameters.map do |parameter_name|
+          domain_ptr = Libevoasm.pop_params_get_domain(self, parameter_name)
+          domain = @domains.find { |domain| domain == domain_ptr }
+          [parameter_name, domain]
+        end.to_h
+      end
+
+      def domains=(domains_hash)
+        domains = []
+        domains_hash.each do |parameter_name, domain_value|
+          domain = Domain.for domain_value
+          success = Libevoasm.pop_params_set_domain(self, parameter_name, domain)
+          if !success
+            raise ArgumentError, "no such parameter #{parameter_name}"
+          end
+          domains << domain
+        end
+
+        # keep reference to prevent disposal by GC
+        @domains = domains
+      end
+
+      # @!visibility private
+      def deme_height
+        Libevoasm.pop_params_get_deme_height self
+      end
+
+      # @!attribute seed
+      # @return [Array<Integer>] the seed for the random number generator
+      def seed
+        Array.new(PRNG::SEED_SIZE) do |index|
+          Libevoasm.pop_params_get_seed(self, index)
+        end
+      end
+
+      def seed=(seed)
+        if seed.size != PRNG::SEED_SIZE
+          raise ArgumentError, 'invalid seed size'
+        end
+
+        seed.each_with_index do |seed_value, index|
+          Libevoasm.pop_params_set_seed(self, index, seed_value)
+        end
+      end
+
+      # Validate the parameters
+      # @raise [Error] if the parameters are invalid
+      def validate!
+        unless Libevoasm.pop_params_validate(self)
+          raise Error.last
+        end
+      end
+
+      # @!attribute instructions
+      # @return [Symbol, Instruction] the list of instructions to use
+      def instructions
+        Array.new(Libevoasm.pop_params_get_n_insts self) do |index|
+          @inst_id_enum_type[Libevoasm.pop_params_get_inst(self, index)]
+        end
+      end
+      def instructions=(instructions)
+        instructions.each_with_index do |instruction, index|
+          name =
+            if instruction.is_a? Symbol
+              instruction
+            else
+              instruction.name
+            end
+          Libevoasm.pop_params_set_inst(self, index, name)
+        end
+        Libevoasm.pop_params_set_n_insts(self, instructions.size)
+      end
+
+      # @!attribute kernel_size
+      # @return [Integer] the size of program kernels (number of instructions per kernel)
+      def kernel_size
+        Libevoasm.pop_params_get_kernel_size self
+      end
+
+      def kernel_size=(kernel_size)
+        Libevoasm.pop_params_set_kernel_size self, kernel_size
+      end
+
+      # @!attribute program_size
+      # @return [Integer] the size of programs (number of kernels per program)
+      def program_size
+        Libevoasm.pop_params_get_program_size self
+      end
+
+      def program_size=(program_size)
+        Libevoasm.pop_params_set_program_size self, program_size
+      end
+
+      # @!attribute recur_limit
+      # @return [Integer] the size of programs (number of kernels per program)
+      def recur_limit
+        Libevoasm.pop_params_get_recur_limit self
+      end
+
+      def recur_limit=(recur_limit)
+        Libevoasm.pop_params_set_recur_limit self, recur_limit
+      end
+
+      # @!attribute examples
+      # @return [Hash] shorthand to set expected program input and output
+      # @see #input
+      # @see #output
+      def examples
+        input.zip(output).to_h
+      end
+
+      def examples=(examples)
+        input_examples = examples.keys.map { |k| Array(k) }
+        output_examples = examples.values.map { |k| Array(k) }
+
+        self.input = Program::Input.new input_examples
+        self.output = Program::Output.new output_examples
+      end
+
+      def input=(input)
+        @input = input
+        Libevoasm.pop_params_set_program_input self, input
+      end
+
+      def output=(output)
+        @output = output
+        Libevoasm.pop_params_set_program_output self, output
+      end
+
+      private
+      def parameters_enum_type
+        @param_id_enum_type
+      end
+    end
+  end
+end

data/lib/evoasm/population/plotter.rb

@@ -0,0 +1,89 @@
+module Evoasm
+  class Population
+
+    # Visualizes the population loss functions using {http://gnuplot.sourceforge.net Gnuplot}
+    class Plotter
+      MAX_SAMPLE_COUNT = 1024
+
+      # @!visibility private
+      def self.__open__
+        @pipe ||= IO.popen('gnuplot -persist', 'w')
+      end
+
+      # @param population [Population] the population to plot
+      def initialize(population, filename = nil)
+        @population = population
+
+        @pipe = self.class.__open__
+        #@pipe = File.open('/tmp/test.txt', 'w')
+
+        if filename
+          case filename
+          when /\.gif$/
+            @pipe.puts 'set term gif animate delay 20 size 1280, 1024 crop'
+            @pipe.puts %Q{set output "#{filename}"}
+          else
+            raise ArgumentError, "unknown output filetype"
+          end
+        end
+
+        @pipe.puts 'set xtics'
+        @pipe.puts 'set ytics'
+        @pipe.puts 'set grid'
+        @pipe.puts 'set style fill transparent solid 0.2 noborder'
+        @pipe.puts 'set datafile missing "Infinity"'
+        @pipe.puts 'set lmargin 0.5'
+        @pipe.puts 'set rmargin 0.5'
+        @pipe.puts 'set tmargin 0.5'
+        @pipe.puts 'set bmargin 0.5'
+      end
+
+      # Updates data points
+      # @return [nil]
+      def update
+        @data ||= Array.new(@population.parameters.deme_count) { Array.new(@population.parameters.deme_height) { [] } }
+        summary = @population.summary
+
+        summary.each_with_index do |deme_summary, deme_index|
+          deme_summary.each_with_index do |layer_summary, layer_index|
+            samples = @data[deme_index][layer_index]
+            samples[samples.size % MAX_SAMPLE_COUNT] = layer_summary
+          end
+        end
+      end
+
+      # Plots (or replots) the current data points
+      # @return [nil]
+      def plot
+        @pipe.puts "set multiplot layout #{@data[0].size}, #{@data.size}"
+
+        key = true
+
+        @data.each do |deme_summary|
+          deme_summary.each do |layer_summary|
+            @pipe.puts "set key #{key ? 'on' : 'off'}"
+            key = false
+            @pipe.write  %Q{plot '-' using 1:2:3 with filledcurves title 'IQR',}
+            @pipe.write %Q{      '-' using 1:2 with lp title 'Min',}
+            @pipe.puts  %Q{      '-' using 1:2 with lp lt 1 pt 5 ps 1.5 lw 2 title 'Median'}
+
+            layer_summary.each_with_index do |sample, sample_index|
+              @pipe.puts "#{sample_index} #{sample[1]} #{sample[3]}"
+            end
+            @pipe.puts 'e'
+            layer_summary.each_with_index do |sample, sample_index|
+              @pipe.puts "#{sample_index} #{sample[0]}"
+            end
+            @pipe.puts 'e'
+            layer_summary.each_with_index do |sample, sample_index|
+              @pipe.puts "#{sample_index} #{sample[2]}"
+            end
+            @pipe.puts 'e'
+          end
+        end
+        @pipe.puts "unset multiplot"
+        @pipe.flush
+      end
+    end
+  end
+end