nimbus 1.0.1 → 2.0.0

data/spec/forest_spec.rb

@@ -2,56 +2,115 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe Nimbus::Forest do
-  before(:each) do
-    @config = Nimbus::Configuration.new
-    @config.load fixture_file('regression_config.yml')
-    @config.load_training_data
-    @forest = ::Nimbus::Forest.new @config
-  end
-  
-  it 'grows a forest of N trees' do
-    @forest.trees.should == []
-    @config.forest_size.should == 3
-    @forest.grow
-    @forest.trees.size.should == @config.forest_size
-    @forest.trees.each{|t| t.should be_kind_of Hash}
-  end
-  
-  it 'creates averaged predictions for individuals in the training set' do
-    @forest.predictions.should == {}
-    @forest.grow
-    (@forest.predictions.keys - (1..800).to_a ).should == []
-    @forest.predictions.values.each{|v| v.should be_kind_of Numeric}
-  end
-  
-  it 'computes averaged SNP importances for every SNP' do
-    @forest.snp_importances.should == {}
-    @forest.grow
-    @forest.snp_importances.keys.sort.should == (1..200).to_a
-    @forest.snp_importances.values.each{|v| v.should be_kind_of Numeric}
-  end
-  
-  it 'traverses a set of testing individuals through every tree in the forest and return predictions' do
-    @forest = @config.load_forest
-    @forest.predictions.should == {}
-    
-    tree_structure = YAML.load(File.open fixture_file('regression_random_forest.yml'))
-    expected_predictions = {}
-    @config.read_testing_data{|individual|
-      individual_prediction = 0.0
-      tree_structure.each do |t|
-        individual_prediction = (individual_prediction + Nimbus::Tree.traverse(t, individual.snp_list)).round(5)
-      end
-      expected_predictions[individual.id] = (individual_prediction / 3).round(5)
-    }
-    
-    @forest.traverse
-    @forest.predictions.should == expected_predictions    
+  describe "Regression" do
+    before(:each) do
+      @config = Nimbus::Configuration.new
+      @config.load fixture_file('regression_config.yml')
+      @config.load_training_data
+      @forest = ::Nimbus::Forest.new @config
+    end
+
+    it 'grows a regression forest of N trees' do
+      @forest.trees.should == []
+      @config.forest_size.should == 3
+      @forest.should_not be_classification
+      @forest.should be_regression
+      @forest.grow
+      @forest.trees.size.should == @config.forest_size
+      @forest.trees.each{|t| t.should be_kind_of Hash}
+    end
+
+    it 'creates averaged predictions for individuals in the training set' do
+      @forest.predictions.should == {}
+      @forest.grow
+      (@forest.predictions.keys - (1..800).to_a ).should == [] # 800 individuals in the training file
+      @forest.predictions.values.each{|v| v.should be_kind_of Numeric}
+    end
+
+    it 'computes averaged SNP importances for every SNP' do
+      @forest.snp_importances.should == {}
+      @forest.grow
+      @forest.snp_importances.keys.sort.should == (1..200).to_a # 200 snps in the training file
+      @forest.snp_importances.values.each{|v| v.should be_kind_of Numeric}
+    end
+
+    it 'traverses a set of testing individuals through every tree in the forest and returns predictions' do
+      @forest = @config.load_forest
+      @forest.predictions.should == {}
+
+      tree_structure = YAML.load(File.open fixture_file('regression_random_forest.yml'))
+      expected_predictions = {}
+      @config.read_testing_data{|individual|
+        individual_prediction = 0.0
+        tree_structure.each do |t|
+          individual_prediction = (individual_prediction + Nimbus::Tree.traverse(t, individual.snp_list)).round(5)
+        end
+        expected_predictions[individual.id] = (individual_prediction / 3).round(5)
+      }
+
+      @forest.traverse
+      @forest.predictions.should == expected_predictions
+    end
+
+    it 'can output forest structure in YAML format' do
+      @forest = @config.load_forest
+      YAML.load(File.open fixture_file('regression_random_forest.yml')) == YAML.load(@forest.to_yaml)
+    end
   end
-  
-  it 'can output forest structure in YAML format' do
-    @forest = @config.load_forest
-    YAML.load(File.open fixture_file('regression_random_forest.yml')) == YAML.load(@forest.to_yaml)
+
+  describe "Classification" do
+    before(:each) do
+      @config = Nimbus::Configuration.new
+      @config.load fixture_file('classification_config.yml')
+      @config.load_training_data
+      @forest = ::Nimbus::Forest.new @config
+    end
+
+    it 'grows a classification forest of N trees' do
+      @forest.trees.should == []
+      @config.forest_size.should == 3
+      @forest.should be_classification
+      @forest.should_not be_regression
+      @forest.grow
+      @forest.trees.size.should == @config.forest_size
+      @forest.trees.each{|t| t.should be_kind_of Hash}
+    end
+
+    it 'creates predictions for individuals in the training set' do
+      @forest.predictions.should == {}
+      @forest.grow
+      (@forest.predictions.keys - (1..1000).to_a ).should == [] # 1000 individuals in the training file
+      @forest.predictions.values.each{|v| v.should be_kind_of String}
+    end
+
+    it 'computes averaged SNP importances for every SNP' do
+      @forest.snp_importances.should == {}
+      @forest.grow
+      @forest.snp_importances.keys.sort.should == (1..100).to_a # 100 snps in the training file
+      @forest.snp_importances.values.each{|v| v.should be_kind_of Numeric}
+    end
+
+    it 'traverses a set of testing individuals through every tree in the forest and returns predictions' do
+      @forest = @config.load_forest
+      @forest.predictions.should == {}
+
+      tree_structure = YAML.load(File.open fixture_file('classification_random_forest.yml'))
+      expected_predictions = {}
+      @config.read_testing_data{|individual|
+        individual_prediction = []
+        tree_structure.each do |t|
+          individual_prediction << Nimbus::Tree.traverse(t, individual.snp_list)
+        end
+        expected_predictions[individual.id] = Nimbus::LossFunctions.majority_class_in_list(individual_prediction, @config.tree[:classes])
+      }
+
+      @forest.traverse
+      @forest.predictions.should == expected_predictions
+    end
+
+    it 'can output forest structure in YAML format' do
+      @forest = @config.load_forest
+      YAML.load(File.open fixture_file('classification_random_forest.yml')) == YAML.load(@forest.to_yaml)
+    end
   end
-  
 end

data/spec/individual_spec.rb

@@ -2,12 +2,12 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe Nimbus::Individual do
-  
+
   it "stores id, fenotype and SNPs information for an individual" do
     @individual = Nimbus::Individual.new(11, 33.275, [1,0,2,1])
     @individual.id.should       == 11
     @individual.fenotype.should == 33.275
     @individual.snp_list.should == [1,0,2,1]
   end
-  
+
 end

data/spec/loss_functions_spec.rb

@@ -0,0 +1,71 @@
+# encoding: UTF-8
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Nimbus::LossFunctions do
+
+  it "method for average" do
+    ids = [1,3,5,7]
+    values = {1 => 10, 2 => 5, 3 => 21, 4 => 8, 5 => 31, 7 => 11, 85 => 22}
+
+    Nimbus::LossFunctions.average(ids, values).should == 18.25 # (10 + 21 + 31 + 11 = 73)/4
+  end
+
+  it "method for mean squared error" do
+    ids = [3,7,85]
+    values = {1 => 10, 2 => 5, 3 => 21, 4 => 8, 5 => 31, 7 => 11, 85 => 22}
+
+    Nimbus::LossFunctions.mean_squared_error(ids, values).should == 74.0 # (avg(21 + 11 + 22) = 18: sum (x-11)^2
+  end
+
+  it "method for quadratic_loss" do
+    ids = [1,4]
+    values = {1 => 10, 2 => 5, 3 => 21, 4 => 8, 5 => 31, 7 => 11, 85 => 22}
+
+    Nimbus::LossFunctions.quadratic_loss(ids, values).round(5).should == 1
+  end
+
+  it "quadratic loss is mean squared error averaged" do
+    ids = [1,2,3,4,5,7,85]
+    values = {1 => 10, 2 => 5, 3 => 21, 4 => 8, 5 => 31, 7 => 11, 85 => 22}
+    Nimbus::LossFunctions.quadratic_loss(ids, values).round(5).should == (Nimbus::LossFunctions.mean_squared_error(ids, values)/7 ).round(5)
+  end
+
+  it "method for squared difference" do
+    Nimbus::LossFunctions.squared_difference(50, 40).should == 100.0
+    Nimbus::LossFunctions.squared_difference(22, 10).should == 144.0
+  end
+
+  it "method for majority class" do
+    ids     = [1,2,3,4,5,7,85]
+    values  = {1 => 'B', 2 => 'C', 3 => 'A', 4 => 'A', 5 => 'C', 7 => 'B', 85 => 'C'} #3C, 2A, 2B
+    classes = ['A', 'B', 'C']
+    Nimbus::LossFunctions.majority_class(ids, values, classes).should == 'C'
+  end
+
+  it "majority class method selects randomly if more than one majority class" do
+    ids     = [1,2,3,4,5,7,85,99]
+    values  = {1 => 'B', 2 => 'C', 3 => 'A', 4 => 'A', 5 => 'C', 7 => 'B', 85 => 'C', 99 => 'A'} #3C, 3A, 2B
+    classes = ['A', 'B', 'C']
+    results = []
+    20.times do
+      results << Nimbus::LossFunctions.majority_class(ids, values, classes)
+    end
+    results.should include('A')
+    results.should include('C')
+  end
+
+  it "method for majority class in list" do
+    list    = %w(A A A B B B C A B C A B A)
+    classes = ['A', 'B', 'C']
+    Nimbus::LossFunctions.majority_class_in_list(list, classes).should == 'A'
+  end
+
+  it "Gini index" do
+    ids     = [1,2,3,4,5,7]
+    values  = {1 => 'B', 2 => 'C', 3 => 'A', 4 => 'A', 5 => 'C', 7 => 'C'} #3C, 2A, 1B
+    classes = ['A', 'B', 'C']
+    # Gini = 1 - ( (3/6)^2 + (2/6)^2 + (1/6)^2 ) = 0.61111
+    Nimbus::LossFunctions.gini_index(ids, values, classes).should == 0.61111
+  end
+
+end

data/spec/nimbus_spec.rb

@@ -3,16 +3,16 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 
 describe 'Nimbus module' do
-  
+
   it "manages a Nimbus::Application object" do
     app = Nimbus.application
     app.should be_kind_of Nimbus::Application
   end
-  
+
   it "accepts setting an external Nimbus::Application" do
-    app = Nimbus::Application.new 
+    app = Nimbus::Application.new
     Nimbus.application = app
     Nimbus.application.should == app
   end
-    
+
 end

data/spec/regression_tree_spec.rb

@@ -0,0 +1,129 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Nimbus::RegressionTree do
+
+  before(:each) do
+    @config = Nimbus::Configuration.new
+    @config.load fixture_file('regression_config.yml')
+
+    @tree = Nimbus::RegressionTree.new @config.tree
+  end
+
+  it "is initialized with tree config info" do
+    @tree.snp_total_count.should == 200
+    @tree.snp_sample_size.should == 60
+    @tree.node_min_size.should   == 5
+  end
+
+  it "creates a tree structure when seeded with training data" do
+    @config.load_training_data
+    @tree.structure.should be_nil
+    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    @tree.structure.should_not be_nil
+    @tree.structure.should be_kind_of Hash
+
+    @tree.structure.keys.first.should == @tree.used_snps.last
+    @tree.used_snps.should_not be_empty
+  end
+
+  it "split node in three when building a node and finds a suitable split" do
+    @config.load_training_data
+    @tree.stub!(:snps_random_sample).and_return((141..200).to_a) #189 is best split
+
+    @tree.individuals = @config.training_set.individuals
+    @tree.id_to_fenotype = @config.training_set.ids_fenotypes
+    @tree.used_snps = []
+    @tree.predictions = {}
+
+    branch = @tree.build_node @config.training_set.all_ids, Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    branch.keys.size.should == 1
+    branch.keys.first.should == 189
+    branch[189].size.should == 3
+    branch[189][0].should be_kind_of Hash
+    branch[189][1].should be_kind_of Hash
+    branch[189][2].should be_kind_of Hash
+  end
+
+  it "keeps track of all SNPs used for the tree" do
+    @config.load_training_data
+    snps = (131..190).to_a
+    @tree.stub!(:snps_random_sample).and_return(snps)
+    @tree.used_snps.should be_nil
+    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    @tree.used_snps.size.should > 4
+    @tree.used_snps.each{|snp|
+      snps.include?(snp).should be_true
+    }
+  end
+
+  it "labels node when building a node and there is not a suitable split" do
+    @config.load_training_data
+    @tree.stub!(:snps_random_sample).and_return([33])
+
+    @tree.individuals = @config.training_set.individuals
+    @tree.id_to_fenotype = @config.training_set.ids_fenotypes
+    @tree.used_snps = []
+    @tree.predictions = {}
+
+    branch = @tree.build_node @config.training_set.all_ids, Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    branch[33][0].should be_kind_of Numeric
+    branch[33][1].should be_kind_of Numeric
+    branch[33][2].should be_kind_of Numeric
+  end
+
+  it "labels node when building a node with less individuals than the minimum node size" do
+    @config.load_training_data
+
+    @tree.individuals = @config.training_set.individuals
+    @tree.id_to_fenotype = @config.training_set.ids_fenotypes
+    @tree.used_snps = []
+    @tree.predictions = {}
+
+    label = @tree.build_node [1, 10, 33], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    label.should be_kind_of Numeric
+
+    label = @tree.build_node [2, 10], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    label.should be_kind_of Numeric
+
+    label = @tree.build_node [1, 10, 33], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    label.should be_kind_of Numeric
+
+    label = @tree.build_node [108, 22, 10, 33], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    label.should be_kind_of Numeric
+  end
+
+  it 'computes generalization error for the tree' do
+    @config.load_training_data
+    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    @tree.generalization_error.should be_nil
+    @tree.generalization_error_from_oob((2..200).to_a)
+    @tree.generalization_error.should be_kind_of Numeric
+    @tree.generalization_error.should > 0.0
+    @tree.generalization_error.should < 1.0
+  end
+
+  it 'estimates importance for all SNPs' do
+    @config.load_training_data
+    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
+    @tree.importances.should be_nil
+    @tree.estimate_importances((300..533).to_a)
+    @tree.importances.should be_kind_of Hash
+    @tree.importances.keys.should_not be_empty
+    (@tree.importances.keys - (1..200).to_a).should be_empty #all keys are snp indexes (200 snps in training file)
+  end
+
+  it 'get prediction for an individual pushing it down a tree structure' do
+    tree_structure = YAML.load(File.open fixture_file('regression_random_forest.yml')).first
+    individual_data = [0]*200
+    prediction = Nimbus::Tree.traverse tree_structure, individual_data
+    prediction.should == 0.25043
+
+    individual_data[189-1] = 1
+    individual_data[4-1] = 1
+    individual_data[62-1] = 2
+    individual_data[146-1] = 2
+    prediction = Nimbus::Tree.traverse tree_structure, individual_data
+    prediction.should == -0.9854
+  end
+
+end

data/spec/training_set_spec.rb

@@ -2,24 +2,24 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe Nimbus::TrainingSet do
-  
+
   it "stores individuals list and fenotype data for them" do
     i1 = Nimbus::Individual.new 1, 11.0, [1,0,2,1]
     i2 = Nimbus::Individual.new 2, 22.0, [2,1,2,2]
     i3 = Nimbus::Individual.new 3, 33.0, [0,2,1,0]
     @training_set = Nimbus::TrainingSet.new [i1, i3], {i1.id => 11.0, i3.id => 33.0}
-    
+
     @training_set.individuals.should   == [i1, i3]
     @training_set.ids_fenotypes.should == {i1.id => 11.0, i3.id => 33.0}
   end
-  
+
   it "keeps track of ids of all individuals in the training set" do
     i1 = Nimbus::Individual.new 1, 11.0, [1,0,2,1]
     i2 = Nimbus::Individual.new 2, 22.0, [2,1,2,2]
     i3 = Nimbus::Individual.new 3, 33.0, [0,2,1,0]
     @training_set = Nimbus::TrainingSet.new [i1, i3], {i1.id => 11.0, i3.id => 33.0}
-    
+
     @training_set.all_ids.should == [1,3]
   end
-  
+
 end

data/spec/tree_spec.rb

@@ -2,129 +2,18 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe Nimbus::Tree do
-  
+
   before(:each) do
     @config = Nimbus::Configuration.new
     @config.load fixture_file('regression_config.yml')
-    
+
     @tree = Nimbus::Tree.new @config.tree
   end
-  
+
   it "is initialized with tree config info" do
     @tree.snp_total_count.should == 200
     @tree.snp_sample_size.should == 60
     @tree.node_min_size.should   == 5
   end
-  
-  it "creates a tree structure when seeded with training data" do
-    @config.load_training_data
-    @tree.structure.should be_nil
-    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    @tree.structure.should_not be_nil
-    @tree.structure.should be_kind_of Hash
-    
-    @tree.structure.keys.first.should == @tree.used_snps.last
-    @tree.used_snps.should_not be_empty
-  end
-  
-  it "split node in three when building a node and finds a suitable split" do
-    @config.load_training_data
-    @tree.stub!(:snps_random_sample).and_return((141..200).to_a) #189 is best split
-    
-    @tree.individuals = @config.training_set.individuals
-    @tree.id_to_fenotype = @config.training_set.ids_fenotypes
-    @tree.used_snps = []
-    @tree.predictions = {}
-    
-    branch = @tree.build_node @config.training_set.all_ids, Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    branch.keys.size.should == 1
-    branch.keys.first.should == 189
-    branch[189].size.should == 3
-    branch[189][0].should be_kind_of Hash
-    branch[189][1].should be_kind_of Hash
-    branch[189][2].should be_kind_of Hash
-  end
-  
-  it "keeps track of all SNPs used for the tree" do
-    @config.load_training_data
-    snps = (131..190).to_a
-    @tree.stub!(:snps_random_sample).and_return(snps)
-    @tree.used_snps.should be_nil
-    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    @tree.used_snps.size.should > 4
-    @tree.used_snps.each{|snp|
-      snps.include?(snp).should be_true
-    }
-  end
-  
-  it "labels node when building a node and there is not a suitable split" do
-    @config.load_training_data
-    @tree.stub!(:snps_random_sample).and_return([33])
-    
-    @tree.individuals = @config.training_set.individuals
-    @tree.id_to_fenotype = @config.training_set.ids_fenotypes
-    @tree.used_snps = []
-    @tree.predictions = {}
-    
-    branch = @tree.build_node @config.training_set.all_ids, Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    branch[33][0].should be_kind_of Numeric
-    branch[33][1].should be_kind_of Numeric
-    branch[33][2].should be_kind_of Numeric
-  end
-  
-  it "labels node when building a node with less individuals than the minimum node size" do
-    @config.load_training_data
-    
-    @tree.individuals = @config.training_set.individuals
-    @tree.id_to_fenotype = @config.training_set.ids_fenotypes
-    @tree.used_snps = []
-    @tree.predictions = {}
-    
-    label = @tree.build_node [1, 10, 33], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    label.should be_kind_of Numeric
-    
-    label = @tree.build_node [2, 10], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    label.should be_kind_of Numeric
-    
-    label = @tree.build_node [1, 10, 33], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    label.should be_kind_of Numeric
-    
-    label = @tree.build_node [108, 22, 10, 33], Nimbus::LossFunctions.average(@config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    label.should be_kind_of Numeric
-  end
-  
-  it 'computes generalization error for the tree' do
-    @config.load_training_data
-    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    @tree.generalization_error.should be_nil
-    @tree.generalization_error_from_oob((2..200).to_a)
-    @tree.generalization_error.should be_kind_of Numeric
-    @tree.generalization_error.should > 0.0
-    @tree.generalization_error.should < 100.0
-  end
-  
-  it 'estimates importance for all SNPs' do
-    @config.load_training_data
-    @tree.seed(@config.training_set.individuals, @config.training_set.all_ids, @config.training_set.ids_fenotypes)
-    @tree.importances.should be_nil
-    @tree.estimate_importances((300..533).to_a)
-    @tree.importances.should be_kind_of Hash
-    @tree.importances.keys.should_not be_empty
-    (@tree.importances.keys - (1..200).to_a).should be_empty
-  end
-  
-  it 'get prediction for an individual pushing it down a tree structure' do
-    tree_structure = YAML.load(File.open fixture_file('regression_random_forest.yml')).first
-    individual_data = [0]*200
-    prediction = Nimbus::Tree.traverse tree_structure, individual_data
-    prediction.should == 0.25043
-    
-    individual_data[189-1] = 1
-    individual_data[4-1] = 1
-    individual_data[62-1] = 2
-    individual_data[146-1] = 2
-    prediction = Nimbus::Tree.traverse tree_structure, individual_data
-    prediction.should == -0.9854
-  end
-  
+
 end