biopsy 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a78e571268545fdd69d110f2b789bb53fa5d100
-  data.tar.gz: 3255fd3579a242fa6277c9b16d5128fe4d3c6250
+  metadata.gz: 3f45b9377c3de44caf8abf21b07576a6e89e0c03
+  data.tar.gz: 94e4a81fe98380482adc7b290f8067174684850d
 SHA512:
-  metadata.gz: dd5c793e5af0042dd69066de1c96695e519d619a8738ad066baefc0d3015dc89ec6247d573090263f45ad3f78ea2bb8fa3df17945197d29bd48b23cee84556bc
-  data.tar.gz: 6a9d2b2dcc4463c1ad8afe3311af4b3912b0263f53c7b1aa609a16319aa5c2348c62a3c48b4caaf7760fa6e0d18df1423644772d7bde2285e10b866f223e4aed
+  metadata.gz: 76d90535589d1f09f74bf424d7437a45855b1065b802bc3ba4d562cc30c1c8fd775583cd856e6de02fee919a9b34619875693a96b228ef686c7e658bb9b29ea5
+  data.tar.gz: 0dbc5e5d21297759affc2199ffff2fe90d25c1958a7380d531811bdded9fbe8caf8eb9fc0aed8b62ecb5d52d6f0f2e2292b480ae8a8e84c79f0e457f44f45c3a

data/README.md

@@ -1,25 +1,43 @@
 biopsy
 ==========
 
+[![Gem Version](https://badge.fury.io/rb/biopsy.png)][gem]
+[![Build Status](https://secure.travis-ci.org/Blahah/biopsy.png?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/Blahah/biopsy.png?travis)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/Blahah/biopsy.png)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/Blahah/biopsy/badge.png?branch=master)][coveralls]
+
+[gem]: https://badge.fury.io/rb/biopsy
+[travis]: https://travis-ci.org/Blahah/biopsy
+[gemnasium]: https://gemnasium.com/Blahah/biopsy
+[codeclimate]: https://codeclimate.com/github/Blahah/biopsy
+[coveralls]: https://coveralls.io/r/Blahah/biopsy
+
 An automatic optimisation framework for programs and pipelines.
 
-Biopsy is a framework for optimising any program or pipeline which produces a measurable output. By reducing the settings of one or more programs to a parameter space, and by carefully choosing objective functions with which to measure the output of the program(s), biopsy can use a range of optimisation strategies to rapidly find the settings that perform the best. Combined with a strategy for subsampling the input data, this can lead to vast time and performance improvements.
+Biopsy is a framework for optimising the settings of any program or pipeline which produces a measurable output. It is particularly intended for bioinformatics, where computational pipelines take a long time to run, making optimisation of parameters using crude methods unfeasible. Biopsy will use a range of discrete optimisation strategies to rapidly find the settings that perform the best.
+
+It can handle parameter spaces of any size: if it is possible to try every parameter combination in the time you have available, Biopsy will do this. However, Biopsy really shines when handling large numbers of parameter combinations.
 
-A simple example of the power of this approach is *de-novo* transcriptome assembly. Typically, the assembly process takes many GB of data as input, uses many GB of RAM and takes many hours to complete. This prevents researchers from performing full parameter sweeps, and they are therefore forced to use word-of-mouth and very basic optimisation to choose assembler settings. [Assemblotron](https://github.com/Blahah/assemblotron), which uses the Biopsy framework, can fully optimise any *de-novo* assembler to produce the optimal assembly possible given a particular input. This typically takes little more time than running a single assembly.
+## Development status
+
+This project is in early development and is not yet ready for deployment.
+Please don't report issues or request documentation until we are ready for release. If you have a burning desire to use biopsy, get in touch: rds45@cam.ac.uk.
 
 ## Installation
 
 Make sure you have Ruby installed, then:
 
-`gem install biopsy --pre`
+`gem install biopsy`
 
 ## Usage
 
 Detailed usage instructions are on the wiki. Here's a quick overview:
 
-1. Define your optimisation target. This is a program or pipeline you want to optimise, and you define it by filling in a template [YAML file](http://en.wikipedia.org/wiki/YAML). Easy!
+1. Define your optimisation target. This is a program or pipeline you want to optimise, and you define it by filling in a template YAML file and wrapping your program in a tiny Ruby launcher.
 2. Define your objective function. This is a program that analyses the output of your program and gives it a score. You define it by writing a small amount of Ruby code. Don't worry - there's a template and detailed instructions on the wiki.
-3. Run Biopsy, and wait while the experiment runs.
+3. Run Biopsy, and wait while the experiment runs. Maybe grab a cup of tea, read some [hacker news](http://news.ycombinator.com).
+4. Bask in the brilliance of your new optimal settings.
 
 ### Command line examples
 
@@ -27,36 +45,11 @@ Detailed usage instructions are on the wiki. Here's a quick overview:
 `biopsy list objectives`
 `biposy run --target test_target --objective test_objective --input test_file.txt --time-limit 24h`
 
-## Development status
+### Optimisation algorithms
 
-[![Gem Version](https://badge.fury.io/rb/biopsy.png)][gem]
-[![Build Status](https://secure.travis-ci.org/Blahah/biopsy.png?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/Blahah/biopsy.png?travis)][gemnasium]
-[![Code Climate](https://codeclimate.com/github/Blahah/biopsy.png)][codeclimate]
-[![Coverage Status](https://coveralls.io/repos/Blahah/biopsy/badge.png?branch=master)][coveralls]
-
-[gem]: https://badge.fury.io/rb/biopsy
-[travis]: https://travis-ci.org/Blahah/biopsy
-[gemnasium]: https://gemnasium.com/Blahah/biopsy
-[codeclimate]: https://codeclimate.com/github/Blahah/biopsy
-[coveralls]: https://coveralls.io/r/Blahah/biopsy
-
-This project is in alpha development and is not yet ready for deployment. 
-Please don't report issues or request documentation until we are ready for beta release (see below for estimated timeframe).
-
-### Roadmap
-
-| Class            | Code   | Tests   | Docs   |
-| ------------     | :----: | ------: | -----: |
-| Settings         | DONE   | DONE    | DONE   |
-| Target           | DONE   | DONE    | DONE   |
-| Domain           | DONE   | DONE    | DONE   |
-| Experiment       | DONE   | DONE    | DONE   |
-| TabuSearch       | DONE   | -       | -      |
-| ParameterSweeper | DONE   | -       | -      |
-| ObjectiveHandler | DONE   | DONE    | DONE   |
-
-* ~ 20/24 tasks completed, ~83% done overall
+1. Parameter Sweeper - a simple combinatorial parameter sweep, with optional subsampling of the parameter space
+2. Tabu Search - a local search with a long memory that takes the consensus of multiple searchers
+3. SPEA2 - a high performance general-purpose genetic algorithm
 
 ### Documentation
 
@@ -68,3 +61,7 @@ This is *pre-release*, *pre-publication* academic software. In lieu of a paper t
 )](http://dx.doi.org/10.6084/m9.figshare.790660) if your use of the software leads to a publication.
 
 [![Analytics](https://ga-beacon.appspot.com/UA-46900280-1/Blahah/biopsy)](https://github.com/Blahah/biopsy)
+
+### Software using Biopsy
+
+- [Assemblotron](https://github.com/Blahah/assemblotron) can fully optimise any *de-novo* transcriptome assembler to produce the optimal assembly possible given a particular input. This typically takes little more time than running a single assembly.

data/lib/biopsy/experiment.rb

@@ -23,10 +23,11 @@ module Biopsy
 
     # Returns a new Experiment
     def initialize(target, options:{}, threads:4, start:nil, algorithm:nil,
-                   verbosity: :quiet)
+                   timelimit:nil, verbosity: :quiet)
       @threads = threads
       @start = start
       @algorithm = algorithm
+      @timelimit = timelimit
       @verbosity = verbosity
       if target.is_a? Target
         @target = target
@@ -78,6 +79,7 @@ module Biopsy
     # are met. On completion, returns the best parameter
     # set.
     def run
+      start_time = Time.now
       in_progress = true
       @algorithm.setup @start
       @current_params = @start
@@ -92,16 +94,21 @@ module Biopsy
            best &&
            best.key?(:score) &&
            @best[:score] > best[:score]
-           puts "found a new best score: #{@best[:score]} \
-                 for parameters #{ptext}"
+           unless @verbosity == :silent
+             puts "found a new best score: #{@best[:score]} "+
+                  "for parameters #{ptext}"
+           end
         end
         # have we finished?
         in_progress = !@algorithm.finished?
+        if in_progress && !(@timelimit.nil?)
+          in_progress = (Time.now - start_time < @timelimit)
+        end
       end
       @algorithm.write_data if @algorithm.respond_to? :write_data
       unless @verbosity == :silent
-        puts "found optimum score: #{@best[:score]} for parameters \
-              #{@best[:parameters]} in #{@iteration_count} iterations."
+        puts "found optimum score: #{@best[:score]} for parameters "+
+             "#{@best[:parameters]} in #{@iteration_count} iterations."
       end
       return @best
     end
@@ -139,7 +146,7 @@ module Biopsy
         puts msg
       end
     end
-    
+
     def cleanup
       # TODO: make this work
       # remove all but essential files

data/lib/biopsy/objective_handler.rb

@@ -93,12 +93,6 @@ module Biopsy
       # objective function(s), with keys as the keys expected by the
       # objective function
       return objective.run(raw_output, output_files, threads)
-    rescue
-      error = "Error: objective function #{objective.class} does not "
-      error << "implement the run() method\nPlease refer to the "
-      error << "documentation for instructions on adding objective functions"
-      # raise NotImplementedError.new("message")
-      raise NotImplementedError, error
     end
 
     # Perform a euclidean distance dimension reduction of multiple objectives

data/lib/biopsy/optimisers/parameter_sweeper.rb

@@ -2,13 +2,16 @@
 # options = {:settings => {...}, :parameters => {...}}
 #
 # Description:
-# ParameterSweeper generates all combinations of a hash of arrays (options[:parameters]).
-# The generated combinations are each   passed in turn to the constructor which returns an execute command
-# incorporating the parameters, and finally the target program is run with each generated command.
+# ParameterSweeper generates all combinations of a hash of arrays
+# (options[:parameters]).
+# The generated combinations are each passed in turn to the constructor
+# which returns an execute command incorporating the parameters, and finally
+# the target program is run with each generated command.
 #
-# The constructor will also have access to an unchanging settings hash (options[:settings])
-# constructor proc will be passed multipule hashes in format: {:settings => {...}, :parameters => {...}}
-# where the values in settings remain constant, and the values in parameters vary 
+# The constructor will also have access to an unchanging settings hash
+# (options[:settings]) constructor proc will be passed multipule hashes in
+# format: {:settings => {...}, :parameters => {...}} where the values in
+# settings remain constant, and the values in parameters vary
 
 require 'pp'
 require 'fileutils'
@@ -17,32 +20,52 @@ require 'threach'
 require 'logger'
 
 module Biopsy
+
+  class Combinator
+
+    include Enumerable
+   
+    def initialize parameters
+      @parameters = parameters
+    end
+   
+    def generate_combinations(index, opts, &block)
+      if index == @parameters.length
+        block.call opts.clone
+        return
+      end
+      # recurse
+      key = @parameters.keys[index]
+      @parameters[key].each do |value|
+        opts[key] = value
+        generate_combinations(index + 1, opts, &block)
+      end
+    end
+
+    def each &block
+      generate_combinations(0, {}, &block)
+    end
+  end
+
   # options - is a hash of two hashes, :settings and :parameters
   #   :ranges are arrays to be parameter sweeped
-  #     ---(single values may be present, these are also remain unchanged but are accessible within the parameters hash to the constructor)
+  #     ---(single values may be present, these are also remain unchanged
+  #     but are accessible within the parameters hash to the constructor)
   class ParameterSweeper
 
-    attr_reader :combinations
+    attr_reader :combinator, :combinations, :best
 
-    def initialize(ranges, threads:1, limit:1000)
+    def initialize(ranges)
       @ranges = ranges
-      # parameter_counter: a count of input parameters to be used
-      @parameter_counter = 1
-      # input_combinations: an array of arrays of input parameters
-      @combinations = []
-      # if the number of threads is set, update the global variable, if not default to 1
-      @threads = threads
-      # set the limit to the number of parameters
-      @limit = limit
-      # convert all options to an array so it can be handled by the generate_combinations() method
+      # convert all options to an array so it can be handled by the
+      # generate_combinations() method
       # ..this is for users entering single values e.g 4 as a parameter
-      @ranges.each { |key, value| value = [value] unless value.kind_of? Array }
-      self.generate_combinations(0, {})
+      @ranges.each_value{ |value| value = [value] unless value.kind_of? Array }
       # restrict to a subsample?
-      
-      if @limit < @combinations.size
-        @combinations = @combinations.sample @limit
-      end
+      @combinations = 1
+      @ranges.each { |r| @combinations *= r[1].size }
+      @is_finished = false
+      @combinator = (Combinator.new @ranges).to_enum
     end
 
     def setup(*_args)
@@ -56,33 +79,23 @@ module Biopsy
     def run_one_iteration(parameters, score)
       @current = { :parameters => parameters, :score => score }
       self.update_best?
-      @combinations.pop
-    rescue
-      nil
+      return @combinator.next
+    rescue 
+      @is_finished = true
+      return nil
     end
 
     def update_best?
+      raise "best is nil. should run setup first" if @best.nil?
       if @best[:score].nil? || @current[:score] > @best[:score]
         @best = @current.clone
       end
     end
 
-    # generate all the parameter combinations to be applied
-    def generate_combinations(index, opts)
-      if index == @ranges.length
-        @combinations << opts.clone
-        return
-      end
-      # recurse
-      key = @ranges.keys[index]
-      @ranges[key].each do |value|
-        opts[key] = value
-        generate_combinations(index + 1, opts)
-      end
-    end
-
-    def best
-      @best
+    def next
+      @combinator.next
+    rescue
+      nil
     end
 
     def knows_starting_point?
@@ -90,15 +103,15 @@ module Biopsy
     end
 
     def select_starting_point
-      @combinations.pop
+      @combinator.next
     end
 
     def random_start_point
-      @combinations.pop
+      @combinator.next
     end
 
     def finished?
-      @combinations.empty?
+      @is_finished
     end
 
     # True if this algorithm chooses its own starting point
@@ -106,4 +119,4 @@ module Biopsy
       true
     end
   end
-end
+end

data/lib/biopsy/version.rb

@@ -6,7 +6,7 @@ module Biopsy
   module VERSION
     MAJOR = 0
     MINOR = 2
-    PATCH = 0
+    PATCH = 1
 
     STRING = [MAJOR, MINOR, PATCH].compact.join('.')
   end

data/lib/biopsy.rb

@@ -5,7 +5,7 @@ require "biopsy/experiment"
 require "biopsy/target"
 require "biopsy/objective_handler"
 require "biopsy/objective_function"
-require "biopsy/optimisers/genetic_algorithm"
+require "biopsy/optimisers/spea2"
 require "biopsy/optimisers/tabu_search"
 require "biopsy/optimisers/parameter_sweeper"
-require "biopsy/objectives/fastest_optimum"
+require "biopsy/objectives/fastest_optimum"

data/test/helper.rb

@@ -57,14 +57,14 @@ class Helper
           opt: true,
           min: -40,
           max: 40,
-          step: 2
+          step: 5
         },
         :b => {
           type: 'integer',
           opt: true,
           min: 0,
           max: 40,
-          step: 2
+          step: 5
         },
         :c => {
           type: 'integer',
@@ -84,8 +84,9 @@ class Helper
   end
 
   # Create a valid target definition in the target dir
-  def create_valid_target
+  def create_valid_target slow: false
     data = self.target_data
+    data[:slow] = slow
     name = 'target_test'
     @target_path = File.join(@target_dir, name + '.yml')
     self.yaml_dump data, @target_path
@@ -99,6 +100,9 @@ class TargetTest
   require 'yaml'
 
   def run(params)
+    if (params[:slow])
+      sleep 0.1
+    end
     File.open('output.txt', 'w') do |f|
       f.puts(params.to_yaml)
     end
@@ -139,6 +143,7 @@ class TestObjective < Biopsy::ObjectiveFunction
     a = input[:a].to_i
     b = input[:b].to_i
     c = input[:c].to_i
+
     value = - Math.sqrt((a-4)**2) - Math.sqrt((b-4)**2) - Math.sqrt((c-4)**2)
     {
       :optimum => @optimum,

data/test/test_experiment.rb

@@ -49,7 +49,7 @@ class TestExperiment < Test::Unit::TestCase
     end
 
     should "respect user's choice of starting point" do
-      s = {:a => 4, :b => 2} 
+      s = {:a => 4, :b => 2}
       e = Biopsy::Experiment.new('target_test', start: s, verbosity: :silent)
       assert_equal s, e.start
     end
@@ -68,13 +68,29 @@ class TestExperiment < Test::Unit::TestCase
       end
     end
 
-    should 'always finish running an experiment' do
-      assert_equal false, true, 'not yet implemented'
+    should 'respect time limits' do
+      # create a slow target
+      target_name = @h.create_valid_target(slow: true)
+      @target = Biopsy::Target.new
+      @target.load_by_name target_name
+      limits = [0.1, 0.2, 0.5, 1]
+      limits.each do |limit|
+        e = Biopsy::Experiment.new('target_test',
+                                   verbosity: :silent, timelimit: limit)
+        start = Time.now
+        e.run
+        finish = Time.now
+        assert (finish - start) < (limit + 0.2)
+      end
+      # reset the target
+      target_name = @h.create_valid_target(slow: false)
+      @target = Biopsy::Target.new
+      @target.load_by_name target_name
     end
 
     should 'run really quickly when starting from the optimal parameters' do
       Dir.chdir @h.tmp_dir do
-        s = {:a => 4, :b => 4, :c => 4} 
+        s = {:a => 4, :b => 4, :c => 4}
         e = Biopsy::Experiment.new('target_test', start: s, verbosity: :silent)
         known_best = -4
         best_found = e.run[:score]
@@ -82,12 +98,12 @@ class TestExperiment < Test::Unit::TestCase
       end
     end
 
-    should 'run using the parameter sweeper (with limit)' do
+    should 'run using the parameter sweeper' do
       Dir.chdir @h.tmp_dir do
-        p = Biopsy::ParameterSweeper.new(@target.parameters, limit: 250)
+        p = Biopsy::ParameterSweeper.new(@target.parameters)
         e = Biopsy::Experiment.new('target_test', algorithm: p, verbosity: :silent)
-        best_found = e.run[:score]
-        assert best_found
+        best_found = e.run[:parameters]
+        assert_equal best_found, {:a=>4, :b=>4, :c=>4}
       end
     end
   end # Experiment context

data/test/test_parametersweep.rb

@@ -7,16 +7,44 @@ class TestParameterSweeper < Test::Unit::TestCase
     setup do
       ranges = {:a => [1,2,3], :b => [1,2,3]}
       @sweep = Biopsy::ParameterSweeper.new(ranges)
+      @sweep.setup
     end
 
-    should "generate a list of combinations" do
+    should "calculate number of combinations" do
       c = @sweep.combinations
-      assert_equal c.size, 9
-      assert_equal c, [{:a=>1, :b=>1}, {:a=>1, :b=>2}, {:a=>1, :b=>3},
+      assert_equal c, 9
+    end
+
+    should 'generate list of combinations' do
+      list=[]
+      9.times do
+        list << @sweep.next
+      end
+      assert_equal list, [{:a=>1, :b=>1}, {:a=>1, :b=>2}, {:a=>1, :b=>3},
        {:a=>2, :b=>1}, {:a=>2, :b=>2}, {:a=>2, :b=>3}, 
        {:a=>3, :b=>1}, {:a=>3, :b=>2}, {:a=>3, :b=>3}]
     end
 
+    should "exit gracefully when you ask for too much" do
+      c = 1
+      10.times do
+        c = @sweep.run_one_iteration(nil, 0)
+      end
+      assert_equal c, nil
+    end
+
+    should 'check if finished' do
+      assert_equal @sweep.finished?, false, "at the start"
+      8.times do
+        @sweep.run_one_iteration(nil, 0)
+      end
+      assert_equal @sweep.finished?, false, "after 8"
+      @sweep.run_one_iteration(nil, 0)
+      assert_equal @sweep.finished?, false, "after 9"
+      @sweep.run_one_iteration(nil, 0)
+      assert_equal @sweep.finished?, true, "after 10"
+    end
+
   end # Experiment context
 
 end # TestExperiment

data/test/test_target.rb

@@ -162,11 +162,12 @@ class TestTarget < Test::Unit::TestCase
       }
       @target.generate_parameters params
       assert_equal @target.parameters, {:a => ["yes", "no", "maybe"]}
-      assert_equal @target.options, {:b=>{:type=>"integer", :opt=>false, :values=>0}}
+      assert_equal @target.options,
+                   {:b=> { :type=>"integer", :opt=>false, :values=>0 } }
     end
 
-    should "pass missing method calls to constructor iff \
-            it directly defines them" do
+    should "pass missing method calls to constructor iff "+
+           "it directly defines them" do
       # this method is defined on the constructor in helper.rb
       assert_send([@target, :fake_method],
                   'valid method not passed to constructor')

metadata

@@ -1,14 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: biopsy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
-- Richard Smith
+- Richard Smith-Unna
+- Parsa Akbari
+- Chris Bournsell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-26 00:00:00.000000000 Z
+date: 2015-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,56 +18,74 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.1'
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
 - !ruby/object:Gem::Dependency
   name: threach
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: rubystats
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.3
 - !ruby/object:Gem::Dependency
   name: statsample
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.4.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -128,46 +148,45 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.7
+        version: '0.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.7
+        version: '0.8'
 description: 
 email: rds45@cam.ac.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE.txt
+- README.md
 - Rakefile
 - lib/biopsy.rb
-- lib/biopsy/version.rb
+- lib/biopsy/base_extensions.rb
+- lib/biopsy/experiment.rb
+- lib/biopsy/objective_function.rb
 - lib/biopsy/objective_handler.rb
 - lib/biopsy/objectives/fastest_optimum.rb
-- lib/biopsy/settings.rb
-- lib/biopsy/optimisers/tabu_search.rb
-- lib/biopsy/optimisers/genetic_algorithm.rb
-- lib/biopsy/optimisers/spea2.rb
 - lib/biopsy/optimisers/parameter_sweeper.rb
-- lib/biopsy/objective_function.rb
+- lib/biopsy/optimisers/spea2.rb
+- lib/biopsy/optimisers/tabu_search.rb
+- lib/biopsy/settings.rb
 - lib/biopsy/target.rb
-- lib/biopsy/base_extensions.rb
-- lib/biopsy/experiment.rb
-- test/test_parametersweep.rb
-- test/test_target.rb
-- test/test_hash.rb
-- test/test_string.rb
-- test/helper.rb
+- lib/biopsy/version.rb
 - test/brokenconfig.yml
-- test/test_objective_handler.rb
+- test/helper.rb
+- test/test_experiment.rb
 - test/test_file.rb
+- test/test_hash.rb
+- test/test_objective_handler.rb
+- test/test_parametersweep.rb
 - test/test_settings.rb
-- test/test_experiment.rb
-- README.md
-- LICENSE.txt
+- test/test_string.rb
+- test/test_target.rb
 homepage: https://github.com/Blahah/biopsy
 licenses: []
 metadata: {}
@@ -187,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.4
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: framework for optimising any computational pipeline or program

data/lib/biopsy/optimisers/genetic_algorithm.rb

@@ -1,244 +0,0 @@
-require 'csv'
-require 'pp'
-
-$global = 0
-
-module Biopsy
-
-  class Generation
-    attr_reader :best, :population_homogenosity
-
-    def initialize (population_size, parameter_ranges)
-      @population_homogenosity = 0
-      @population_size = population_size
-      @current_generation = []
-      @ranges = parameter_ranges
-      @MUTATION_RATE = 0.40
-      @best = {
-        :parameters => nil,
-        :score => 0.0
-      }
-    end
-
-    # insert the next chromosome into the generation
-    def next_chromosome (chromosome)
-      @current_generation += [chromosome]
-    end
-
-    def update_best? (current)
-      @best = current if current[:score] > @best[:score]
-    end
-
-    # is the generation now full?
-    def last?
-      return @current_generation.length == @population_size
-    end
-
-    def run_generation
-      #pp @current_generation if $global%100 == 0
-      $global += 1
-      #homogeneous_test
-      selection_process
-      crossover
-
-      return @current_generation
-    end
-
-    ###################################
-    # ----remainder stochastic sampling (stochastic universal sampling method)----
-    # apply obj function on parameter_sets, rank parameter_sets by obj func score
-    # scale obj func score to ranking where: highest rank=2, lowest rank=0
-    # for each integer in rank reproduce += 1, for decimal allow random reproduction (based on size of decimal)
-    def selection_process
-      current_generation_temp = []
-      #apply obj func on all params, store score in @current_generation[X][:score]
-      @current_generation.each do |chromosome|
-        current_generation_temp << {:parameters => chromosome[:parameters], :score => chromosome[:score]}
-      end
-      # sort @current_generation by objective function score (ASC), replace @current_generation w/ temporary array
-      @current_generation = current_generation_temp.sort {|a, b| a[:score] <=> b[:score]}
-      # the highest rank is 2.0, generate step_size (difference in rank between each element)
-      step_size = 2.0/(@current_generation.length-1)
-      # counter to be used when assigning rank
-      counter = 0
-      # next_generation temporary array, @current_generation is replaced by next_generation after loop
-      next_generation = []
-      # switch scores with ranks
-      @current_generation.each do |chromosome|
-        # rank (asc) is the order in which the element appears (counter) times step_size so that the max is 2
-        rank = counter * step_size
-        next_generation << {:parameters => chromosome[:parameters], :score => rank} if rank >= 1.0
-        next_generation << {:parameters => chromosome[:parameters], :score => rank} if rank >= 2.0
-        next_generation << {:parameters => chromosome[:parameters], :score => rank} if rand <= rank.modulo(1)
-        counter += 1
-      end
-      # if population is too small
-      while next_generation.length < @population_size
-        select_chromosome = next_generation.sample(1)[0]
-        next_generation << select_chromosome
-      end
-      while next_generation.length > @population_size
-        select_chromosome_index = next_generation.index(next_generation.sample(1)[0])
-        next_generation.delete_at(select_chromosome_index)
-      end
-      # sort @current_generation by objective function score (ASC), replace @current_generation w/ temporary array
-      @current_generation = next_generation.sort {|a, b| a[:score] <=> b[:score]}
-      return
-    end
-
-    def crossover
-      def mating_process(mother, father)
-        children = [{:parameters=>{}}, {:parameters=>{}}]
-        mother[:parameters].each do |mother_key, mother_value|
-          if rand <= 0.5
-            children[0][:parameters][mother_key.to_sym] = mother_value
-            children[1][:parameters][mother_key.to_sym] = father[:parameters][mother_key.to_sym]
-          else
-            children[0][:parameters][mother_key.to_sym] = father[:parameters][mother_key.to_sym]
-            children[1][:parameters][mother_key.to_sym] = mother_value
-          end
-        end
-        return children
-      end
-      # mate the best quarter with the best half
-      best_quarter_num = (@current_generation.length.to_f/4.0).round
-      best_half_num = best_quarter_num
-
-      best_quarter = @current_generation[-best_quarter_num..-1]
-      best_half = @current_generation[-(best_quarter_num+best_half_num)..-(best_quarter_num+1)]
-      children = []
-      best_quarter.each do |father|
-        twins = mating_process(best_half.shuffle!.pop, father)
-        children += twins.map{|value| value}
-      end
-      (0..(children.length-1)).each do |num|
-        @current_generation.delete_at(0)
-      end
-      children.each do |child|
-        if @MUTATION_RATE > rand
-          children.delete_at(children.index(child))
-          children += [generateMutation(child)]
-        end
-      end
-
-      @current_generation += children
-      return true
-    end
-
-    def generateMutation chromosome
-      if !@mutation_wheel
-        @mutation_wheel = [{}, 0]
-        total_param_ranges = 0
-        @ranges.each do |key, value|
-          next if value.length <= 1
-          total_param_ranges += value.length
-          @mutation_wheel[0][key.to_sym] = total_param_ranges
-        end
-        @mutation_wheel[1] = total_param_ranges
-      end
-      mutation_location = rand(1..@mutation_wheel[1])
-      temp_options_params = Marshal.load(Marshal.dump(@ranges))
-      @mutation_wheel[0].each do |key, value|
-        next if value < mutation_location
-        temp_options_params[key.to_sym].delete(chromosome[:parameters][key.to_sym])
-        chromosome[:parameters][key.to_sym] = temp_options_params[key.to_sym].sample(1)[0]
-        break
-      end
-      return chromosome
-    end
-
-    def homogeneous_test
-      homo_val = 0
-      (0..(@current_generation.length-1)).each do |i|
-         (i..(@current_generation.length-1)).each do |j|
-            next if i == j
-            @current_generation[i][:parameters].each do |key, val|
-              homo_val += 1 if val == @current_generation[j][:parameters][key.to_sym]
-            end
-          end
-      end
-      n_value = @current_generation.length-1
-      sum = (n_value/2)*(n_value+1)
-      @population_homogenosity = (homo_val/(sum*@current_generation[0][:parameters].length).to_f)
-    end
-
-    def get_population
-      if self.last?
-        return @current_generation
-      else
-        return false
-      end
-    end
-
-  end # Generation
-
-
-  class GeneticAlgorithm
-    attr_reader :current, :best, :generation_no, :get_homog
-
-    def initialize (population_size, parameter_ranges)
-      @ranges = parameter_ranges
-      @population_size = population_size
-      @current_generation = Generation.new(@population_size, @ranges)
-      @best = {
-        :parameters => nil,
-        :score => 0.0
-      }
-    end
-
-    def run
-      nil
-    end
-
-    def run_one_iteration (parameters, score)
-        @current = {:parameters => parameters, :score => score}
-        # update best score?
-        self.update_best? @current
-        # push next chromosome to GA, generation will compute if population size is full
-        return self.next_candidate @current
-        # update tabu list
-        #self.update_tabu
-        #@current
-    end
-
-    def update_best? (current)
-        # ... runs an identical method in GenerationHandler 
-        @current_generation.update_best? current
-        @best = current if current[:score] > @best[:score]
-    end
-
-    def next_candidate (chromosome)
-      # .. will run update ga if @current_generation.last? is true
-      @current_generation.next_chromosome(chromosome)
-
-      if @current_generation.last?
-        return self.update_ga
-      end
-      return @current
-    end
-
-    def update_ga
-      # ... will run to next generation
-      store = @current_generation.run_generation
-      @current_generation.homogeneous_test
-      @get_homog = @current_generation.population_homogenosity
-      @current_generation = Generation.new(@population_size, @ranges)
-      return store
-    end
-
-    def finished?
-      false
-    end
-
-    ##############################
-    def generate_chromosome
-      return Hash[@ranges.map { |param, range| [param, range.sample] }]
-    end
-    
-    def get_population
-      return @current_generation.get_population
-    end
-
-  end # GeneticAlgorithm
-
-end # Biopsy