nimbus 0.1

data/MIT-LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Juanjo Bazán & Oscar González Recio
+
+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.

data/README.rdoc

@@ -0,0 +1 @@
+= Nimbus

data/bin/nimbus

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+#--
+# Copyright (c) 2011 Juanjo Bazan
+#
+# 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 'nimbus'
+Nimbus.application.run

data/lib/nimbus/application.rb

@@ -0,0 +1,77 @@
+module Nimbus
+  
+  #####################################################################
+  # Nimbus main application object. When invoking +nimbus+ from the
+  # command line, a Nimbus::Application object is created and run.
+  #
+  class Application
+    attr_accessor :config
+    
+    # Initialize a Nimbus::Application object.
+    # Check and load the configuration options.
+    #
+    def initialize
+      nimbus_exception_handling do
+        config.load
+      end
+    end
+    
+    # Run the Nimbus application. The run method performs the following
+    # two steps:
+    #
+    # * Creates a Nimbus::Forest object.
+    # * Writes results to output files.
+    def run
+      nimbus_exception_handling do
+        forest = ::Nimbus::Forest.new @config
+        forest.grow if @config.do_training && @config.load_training_data
+        output_random_forest_file(forest)
+      end
+    end
+
+    # Createas an instance of Nimbus::Configuration if it does not exist.
+    def config
+      @config ||= ::Nimbus::Configuration.new
+    end
+    
+    # Provide exception handling for the given block.
+    def nimbus_exception_handling
+      begin
+        yield
+      rescue SystemExit => ex
+        raise
+      rescue OptionParser::InvalidOption => ex
+        display_error_message(Nimbus::InvalidOptionError ex.message)
+        Nimbus.stop
+      rescue Nimbus::Error => ex
+        display_error_message(ex)
+        Nimbus.stop
+      rescue Exception => ex
+        display_error_message(ex)
+        Nimbus.stop
+      end
+    end
+    
+    # Display the error message that caused the exception.
+    def display_error_message(ex)
+      Nimbus.error_message "* Nimbus encountered an error! The random forest was not generated *"
+      Nimbus.error_message "#{ex.class}: #{ex.message}"
+      # if config.trace
+          Nimbus.error_message ex.backtrace.join("\n")
+      # else
+      #   Nimbus.error_message "(See full error trace by running Nimbus with --trace)"
+      # end
+    end
+    
+    protected
+    def output_random_forest_file(forest)
+      File.open(@config.output_forest_file , 'w') {|f| f.write(forest.to_yaml) }
+      Nimbus.message "* Resulting forest structure be saved to:"
+      Nimbus.message "*   Output forest file: #{@config.output_forest_file}"
+      Nimbus.message "*" * 50
+      
+    end
+    
+  end
+  
+end

data/lib/nimbus/configuration.rb

@@ -0,0 +1,153 @@
+module Nimbus
+  class Configuration
+    attr_accessor(
+      :training_file,
+      :testing_file,
+      :forest_file,
+      :config_file,
+      :forest_size,
+      :tree_SNP_sample_size,
+      :tree_SNP_total_count,
+      :tree_max_branches,
+      :tree_node_min_size,
+      :loss_function_discrete,
+      :loss_function_continuous,
+      :do_training,
+      :do_testing,
+      :training_set,
+      :output_forest_file
+    )
+    
+    DEFAULTS = {
+      :forest_size          => 500,
+      :tree_SNP_sample_size => 60,
+      :tree_SNP_total_count => 200,
+      :tree_max_branches    => 2000,
+      :tree_node_min_size   => 5,
+      
+      :loss_function_discrete   => 'majority_class',
+      :loss_function_continuous => 'mean',
+      
+      :training_file => 'training.data',
+      :testing_file  => 'testing.data',
+      :forest_file   => 'forest.yml',
+      :config_file   => 'config.yml',
+      
+      :output_forest_file => 'random_forest.yml'
+    }
+    
+    
+    def initialize
+      @do_training = false
+      @do_testing  = false
+      
+      @forest_size              = DEFAULTS[:forest_size]
+      @tree_SNP_sample_size     = DEFAULTS[:tree_SNP_sample_size]
+      @tree_SNP_total_count     = DEFAULTS[:tree_SNP_total_count]
+      @tree_max_branches        = DEFAULTS[:tree_max_branches]
+      @tree_node_min_size       = DEFAULTS[:tree_node_min_size]
+      @loss_function_discrete   = DEFAULTS[:loss_function_discrete]
+      @loss_function_continuous = DEFAULTS[:loss_function_continuous]
+      
+      @output_forest_file = File.expand_path(DEFAULTS[:output_forest_file], Dir.pwd)
+    end
+    
+    def tree
+      { 
+        :snp_sample_size => @tree_SNP_sample_size,
+        :snp_total_count => @tree_SNP_total_count,
+        :tree_max_branches => @tree_max_branches,
+        :tree_node_min_size => @tree_node_min_size
+      }
+    end
+    
+    def load(config_file = DEFAULTS[:config_file])
+      user_config_params = {}
+      if File.exists?(File.expand_path(config_file, Dir.pwd))
+        begin
+          user_config_params = YAML.load(File.open(File.expand_path config_file, Dir.pwd))
+        rescue ArgumentError => e
+          raise Nimbus::WrongFormatFileError, "It was not posible to parse the config file (#{config_file}): \r\n#{e.message} "
+        end
+      end
+      
+      if user_config_params['input']
+        @training_file = File.expand_path(user_config_params['input']['training'], Dir.pwd) if user_config_params['input']['training']
+        @testing_file  = File.expand_path(user_config_params['input']['testing' ], Dir.pwd) if user_config_params['input']['testing']
+        @forest_file   = File.expand_path(user_config_params['input']['forest'  ], Dir.pwd) if user_config_params['input']['forest']
+      else
+        @training_file = File.expand_path(DEFAULTS[:training_file], Dir.pwd) if File.exists? File.expand_path(DEFAULTS[:training_file], Dir.pwd)
+        @testing_file  = File.expand_path(DEFAULTS[:testing_file ], Dir.pwd) if File.exists? File.expand_path(DEFAULTS[:testing_file ], Dir.pwd)
+        @forest_file   = File.expand_path(DEFAULTS[:forest_file  ], Dir.pwd) if File.exists? File.expand_path(DEFAULTS[:forest_file  ], Dir.pwd)
+      end
+      
+      @do_training = true if @training_file
+      @do_testing  = true if @testing_file
+      
+      if @do_testing && !@do_training && !@forest_file
+        raise Nimbus::InputFileError, "There is not random forest data (training file not defined, and forest file not found)."
+      end
+      
+      if user_config_params['forest']
+        @forest_size          = user_config_params['forest']['forest_size'].to_i if user_config_params['forest']['forest_size']
+        @tree_SNP_total_count = user_config_params['forest']['SNP_total_count'].to_i if user_config_params['forest']['SNP_total_count']
+        @tree_SNP_sample_size = user_config_params['forest']['SNP_sample_size_mtry'].to_i  if user_config_params['forest']['SNP_sample_size_mtry']
+        @tree_max_branches    = user_config_params['forest']['max_branches'].to_i  if user_config_params['forest']['max_branches']
+        @tree_node_min_size   = user_config_params['forest']['node_min_size'].to_i if user_config_params['forest']['node_min_size']
+      end
+      
+      check_configuration
+      log_configuration
+    end
+    
+    def load_training_data
+      File.open(@training_file) {|file|
+        @training_set = Nimbus::TrainingSet.new({}, {})
+        file.each do |line|
+          next if line.strip == ''
+          data_feno, data_id, *snp_list = line.strip.split
+          raise Nimbus::InputFileError, "Individual ##{data_id} from training set has no value for all #{@tree_SNP_total_count} SNPs" unless snp_list.size == @tree_SNP_total_count
+          @training_set.individuals[data_id.to_i] = Nimbus::Individual.new(data_id.to_i, data_feno.to_f, snp_list.map{|snp| snp.to_i})
+          @training_set.ids_fenotypes[data_id.to_i] = data_feno.to_f
+        end
+      }
+    end
+    
+    def load_testing_data
+    end
+    
+    def load_forest_data
+    end
+    
+    def check_configuration
+      raise Nimbus::ConfigurationError, "The mtry sample size must be smaller than the total SNPs count." if @tree_SNP_sample_size > @tree_SNP_total_count
+    end
+    
+    def log_configuration
+      Nimbus.message "*" * 50
+      Nimbus.message "* Nimbus configured with the following parameters: "
+      Nimbus.message "*   Forest size: #{@forest_size} trees"
+      Nimbus.message "*   Total SNP count: #{@tree_SNP_total_count}"
+      Nimbus.message "*   SNPs sample size (mtry): #{@SNP_sample_size}"
+      Nimbus.message "*   Maximum number of branches per tree: #{@tree_max_branches}"
+      Nimbus.message "*   Minimun node size in tree: #{@tree_node_min_size}"
+      Nimbus.message "*" * 50
+      if @do_training
+        Nimbus.message "* Training data:"
+        Nimbus.message "*   Training file: #{@training_file}"
+        Nimbus.message "*" * 50
+      end
+      
+      if @do_testing
+        Nimbus.message "* Data to be tested:"
+        Nimbus.message "*   Testing file: #{@testing_file}"
+        if @forest_file && !@do_training
+          Nimbus.message "* using the structure of the random forest stored in:" 
+          Nimbus.message "*   Random forest file: #{@forest_file}"
+        end
+        Nimbus.message "*" * 50
+      end
+    end
+    
+  end
+end

data/lib/nimbus/exceptions.rb

@@ -0,0 +1,10 @@
+module Nimbus
+  class Error < StandardError; end
+  class InvalidOptionError < Error; end
+  class InputFileError < Error; end
+  class WrongFormatFileError < Error; end
+  class ConfigurationError < Error; end
+  class ForestError < Error; end
+  class TreeError < Error; end
+  class IndividualError < Error; end
+end

data/lib/nimbus/forest.rb

@@ -0,0 +1,38 @@
+module Nimbus
+  
+  class Forest
+    attr_accessor :size, :trees
+    attr_accessor :options
+    
+    def initialize(config)
+      @trees = []
+      @options = config
+      @size = config.forest_size
+      raise Nimbus::ForestError, "Forest size parameter (#{@size}) is invalid. You need at least one tree." if @size < 1
+    end
+    
+    def grow
+      i=0
+      @size.times do
+        i+=1
+        tree = Tree.new @options.tree
+        @trees << tree.seed(@options.training_set.individuals, individuals_random_sample, @options.training_set.ids_fenotypes)
+        #OOB << Tree.traverse OOB por el tree.
+      end
+    end
+    
+    def to_yaml
+      @trees.to_yaml
+    end
+    
+    
+    private
+    
+    def individuals_random_sample
+      bag = (1..@options.training_set.individuals.size).to_a
+      individuals_sample = bag.inject([]){|items, i| items << bag.sample }.sort
+    end
+    
+  end
+  
+end

data/lib/nimbus/individual.rb

@@ -0,0 +1,13 @@
+module Nimbus
+  
+  class Individual
+    attr_accessor :id, :fenotype, :prediction, :snp_list
+    
+    def initialize(i, fen, snps={})
+      self.id = i
+      self.fenotype = fen
+      self.snp_list = snps
+    end
+  end
+  
+end

data/lib/nimbus/loss_functions.rb

@@ -0,0 +1,23 @@
+module Nimbus
+  module LossFunctions
+    
+    class << self
+   
+      def average(ids, value_table)
+        ids.inject(0.0){|sum, i| sum + value_table[i]} / ids.size
+      end
+
+      def mean_squared_error(ids, value_table, mean = nil)
+        mean ||= self.average ids, value_table
+        ids.inject(0.0){|sum, i| sum + ((value_table[i] - mean)**2) }
+      end
+
+      def quadratic_loss(ids, value_table, mean = nil)
+        self.mean_squared_error(ids, value_table, mean) / ids.size
+      end
+      
+    end
+    
+  end
+end
+    

data/lib/nimbus/training_set.rb

@@ -0,0 +1,12 @@
+module Nimbus
+  
+  class TrainingSet
+    attr_accessor :individuals, :ids_fenotypes
+    
+    def initialize(individuals, ids_fenotypes)
+      @individuals   = individuals
+      @ids_fenotypes = ids_fenotypes
+    end
+  end
+  
+end

data/lib/nimbus/tree.rb

@@ -0,0 +1,84 @@
+module Nimbus
+  
+  class Tree
+    attr_accessor :snp_sample_size, :snp_total_count, :node_min_size, :max_branches, :structure
+    attr_accessor :individuals, :id_to_fenotype
+    
+    def initialize(options)
+      @snp_total_count = options[:snp_total_count]
+      @snp_sample_size = options[:snp_sample_size]
+      @node_min_size = options[:tree_node_min_size]
+      @max_branches = options[:tree_max_branches]
+    end
+    
+    def seed(all_individuals, individuals_sample, ids_fenotypes)
+      @individuals = all_individuals
+      @id_to_fenotype = ids_fenotypes
+      
+      @structure = build_node individuals_sample, Nimbus::LossFunctions.average(individuals_sample, @id_to_fenotype)
+    end
+
+    def build_node(individuals_ids, y_hat)
+      # General loss function value for the node
+      individuals_count = individuals_ids.size
+      return y_hat.round(5) if individuals_count < @node_min_size
+      node_loss_function = Nimbus::LossFunctions.quadratic_loss individuals_ids, @id_to_fenotype, y_hat
+      
+      # Finding the SNP that minimizes loss function
+      snps = snps_random_sample
+      min_loss, min_SNP, split, means  = node_loss_function, nil, nil, nil
+
+      snps.each do |snp|
+        individuals_split_by_snp_value = split_by_snp_value individuals_ids, snp
+        mean_0 = Nimbus::LossFunctions.average individuals_split_by_snp_value[0], @id_to_fenotype
+        mean_1 = Nimbus::LossFunctions.average individuals_split_by_snp_value[1], @id_to_fenotype
+        mean_2 = Nimbus::LossFunctions.average individuals_split_by_snp_value[2], @id_to_fenotype
+        loss_0 = Nimbus::LossFunctions.mean_squared_error individuals_split_by_snp_value[0], @id_to_fenotype, mean_0
+        loss_1 = Nimbus::LossFunctions.mean_squared_error individuals_split_by_snp_value[1], @id_to_fenotype, mean_1
+        loss_2 = Nimbus::LossFunctions.mean_squared_error individuals_split_by_snp_value[2], @id_to_fenotype, mean_2
+        loss_snp = (loss_0 + loss_1 + loss_2) / individuals_count
+        
+        min_loss, min_SNP, split, means = loss_snp, snp, individuals_split_by_snp_value, [mean_0, mean_1, mean_2] if loss_snp < min_loss
+      end
+      
+      
+      return build_branch(min_SNP, split, means, y_hat) if min_loss < node_loss_function
+      return y_hat.round(5)
+    end
+    
+    def build_branch(snp, split, y_hats, parent_y_hat)
+      node_0 = split[0].size == 0 ? parent_y_hat.round(5) : build_node(split[0], y_hats[0])
+      node_1 = split[1].size == 0 ? parent_y_hat.round(5) : build_node(split[1], y_hats[1])
+      node_2 = split[2].size == 0 ? parent_y_hat.round(5) : build_node(split[2], y_hats[2])
+      
+      return { snp => [node_0, node_1, node_2] }
+    end
+    
+    def traverse
+      
+    end
+    
+    def self.traverse(structure, data)
+      
+    end
+    
+    
+    private
+    
+    def snps_random_sample
+      (1..@snp_total_count).to_a.sample(@snp_sample_size).sort
+    end
+    
+    def split_by_snp_value(ids, snp)
+      split = [[], [], []]
+      ids.each do |i|
+        split[ @individuals[i].snp_list[snp-1] ] << @individuals[i].id
+      end
+      split
+    rescue => ex
+      raise Nimbus::TreeError, "Values for SNPs columns must be in [0, 1, 2]"
+    end
+    
+  end
+  
+end

data/lib/nimbus.rb

@@ -0,0 +1,48 @@
+require 'yaml'
+require 'optparse'
+require 'nimbus/exceptions'
+require 'nimbus/training_set'
+require 'nimbus/configuration'
+require 'nimbus/loss_functions'
+require 'nimbus/individual'
+require 'nimbus/tree'
+require 'nimbus/forest'
+require 'nimbus/application'
+
+module Nimbus
+  
+  STDERR = $stderr
+  STDOUT = $stdout
+  
+  # Nimbus module singleton methods.
+  #
+  class << self
+    # Current Nimbus Application
+    def application
+      @application ||= ::Nimbus::Application.new
+    end
+    
+    # Set the current Nimbus application object.
+    def application=(app)
+      @application = app
+    end
+    
+    # Stops the execution of the Nimbus application.
+    def stop(msg = "Error: Nimbus finished.")  # :nodoc:
+      STDERR.puts msg
+      exit(false)
+    end
+    
+    # Writes message to the standard output
+    def message(msg)
+      STDOUT.puts msg
+    end
+    
+    # Writes message to the error output
+    def error_message(msg)
+      STDERR.puts msg
+    end
+    
+  end
+  
+end

data/spec/fixtures/config.yml

@@ -0,0 +1,14 @@
+#Input files
+input:
+  training: Rtraining.h40
+  testing:  Rtesting.h40
+
+#Forest parameters
+forest:
+  forest_size: 500 #how many trees
+  SNP_sample_size_mtry: 60 #mtry
+  SNP_total_count: 200
+  max_branches: 2000
+  node_min_size: 5
+  loss_function_discrete: 2
+  loss_function_cont: 2

data/spec/nimbus_spec.rb

@@ -0,0 +1,2 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + '/spec_helper'

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + '/../lib/nimbus'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: nimbus
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: "0.1"
+platform: ruby
+authors: 
+- "Juanjo Baz\xC3\xA1n"
+- "Oscar Gonz\xC3\xA1lez Recio"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-01 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id001
+description: Nimbus is a Ruby gem to implement Random Forest in a genomic selection context.
+email: 
+- jjbazan@gmail.com
+executables: 
+- nimbus
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE.txt
+- README.rdoc
+- lib/nimbus/application.rb
+- lib/nimbus/configuration.rb
+- lib/nimbus/exceptions.rb
+- lib/nimbus/forest.rb
+- lib/nimbus/individual.rb
+- lib/nimbus/loss_functions.rb
+- lib/nimbus/training_set.rb
+- lib/nimbus/tree.rb
+- lib/nimbus.rb
+- spec/fixtures/config.yml
+- spec/nimbus_spec.rb
+- spec/spec_helper.rb
+- bin/nimbus
+homepage: http://github.com/xuanxu/nimbus
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+- --charset=UTF-8
+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.6
+signing_key: 
+specification_version: 3
+summary: Random Forest algorithm for Genomics
+test_files: 
+- spec/fixtures/config.yml
+- spec/nimbus_spec.rb
+- spec/spec_helper.rb