fselector 0.1.0

data/lib/fselector/base_continuous.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + '/algo_continuous/normalizer.rb')
+require File.expand_path(File.dirname(__FILE__) + '/algo_continuous/discretizer.rb')
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# base ranking algorithm for handling continous feature
+#
+  class BaseContinuous < Base
+    # include normalizer
+    include Normalizer
+    # include discretilizer
+    include Discretilizer
+    
+    # initialize from an existing data structure
+    def initialize(data=nil)
+      super(data)
+    end
+    
+
+  end # class
+
+
+end # module

data/lib/fselector/base_discrete.rb

@@ -0,0 +1,355 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+#  base ranking alogrithm for handling discrete feature
+#
+#     2 x 2 contingency table
+#     
+#           c   c'
+#         ---------
+#      f  | A | B | A+B
+#         |---|---| 
+#      f' | C | D | C+D
+#         ---------
+#          A+C B+D  N = A+B+C+D
+#     
+#      P(f)     = (A+B)/N
+#      P(f')    = (C+D)/N
+#      P(c)     = (A+C)/N
+#      P(c')    = (B+D)/N
+#      P(f,c)   = A/N
+#      P(f,c')  = B/N
+#      P(f',c)  = C/N
+#      P(f',c') = D/N
+#
+  class BaseDiscrete < Base
+    # initialize from an existing data structure
+    def initialize(data=nil)
+      super(data)
+    end
+
+    private
+    
+    # count of sample (i.e. 'A' or CT00) that
+    # contains feature (f = v) and belongs to class (k)
+    def get_Av(f, k, v)
+      @Av ||= calc_Av
+      a = @Av[k][f][v]
+      
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      #a+=0.5 if a.zero?
+      
+      a
+    end
+    
+    
+    # pre-compute 'A' or CT00
+    # feature (f) has categorical values
+    def calc_Av
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          results[k1][f] = {}
+          
+          get_feature_values(f).each do |v|
+            count = 0.0
+
+            each_sample do |k2, s|
+              if k2 == k1
+                count += 1 if s.has_key? f and s[f] == v
+              end
+            end
+            
+            results[k1][f][v] = count
+          end
+        end
+      end
+      
+      results
+      
+    end
+
+    
+    # count of sample (i.e. 'B' or CT01) that
+    # contains feature (f = v) but does not belong to class (k)
+    def get_Bv(f, k, v)
+      @Bv ||= calc_Bv
+      b = @Bv[k][f][v]
+            
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      #b+=0.5 if b.zero?
+      
+      b
+    end
+    
+    
+    # pre-compute 'B' or CT01
+    # feature (f) has categorical values
+    def calc_Bv
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          results[k1][f] = {}
+          
+          get_feature_values(f).each do |v|
+            count = 0.0
+            
+            each_sample do |k2, s|
+              if k2 != k1
+                count += 1 if s.has_key? f and s[f] == v
+              end
+            end
+          
+            results[k1][f][v] = count
+          end
+        end
+      end
+      
+      results
+    end
+
+
+    # count of sample (i.e. 'C' or CT10) that
+    # does not contain feature (f != v) but belongs to class (k)
+    def get_Cv(f, k, v)
+      @Cv ||= calc_Cv
+      c = @Cv[k][f][v]
+      
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      #c+=0.5 if c.zero?
+      
+      c
+    end
+    
+  
+    # pre-compute 'C' or CT10
+    # feature (f) has categorical values
+    def calc_Cv
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          results[k1][f] = {}
+          
+          get_feature_values(f).each do |v|
+            count = 0.0
+          
+            each_sample do |k2, s|
+              if k2 == k1
+                count += 1 if not s.has_key? f or s[f] != v
+              end
+            end
+          
+            results[k1][f][v] = count
+          end
+        end
+      end
+      
+      results
+    end
+
+
+    # count of sample (i.e. 'D' or CT11) that
+    # does not contain feature (f) and does not belong to class (c)
+    def get_Dv(f, k, v)
+      @Dv ||= calc_Dv
+      d = @Dv[k][f][v]
+           
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      #d+=0.5 if d.zero?
+      
+      d
+    end
+
+    
+    # pre-compute 'D' or CT11
+    # feature (f) has categorical values
+    def calc_Dv
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          results[k1][f] = {}
+          
+          get_feature_values(f).each do |v|
+            count = 0.0
+          
+            each_sample do |k2, s|
+              if k2 != k1
+                count += 1 if not s.has_key? f or s[f] != v
+              end
+            end
+          
+            results[k1][f][v] = count
+          end
+        end
+      end
+      
+      results
+    end
+    
+    
+    # count of sample (i.e. 'A') that
+    # contains feature (f) and belongs to class (k)
+    def get_A(f, k)
+      @A ||= calc_A
+      a = @A[k][f]
+      
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      a+=0.5 if a.zero?
+      
+      a 
+    end
+
+    
+    # pre-compute 'A'
+    def calc_A
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          count = 0.0
+          
+          each_sample do |k2, s|
+            if k2 == k1
+              count += 1 if s.has_key? f
+            end
+          end
+          
+          results[k1][f] = count
+        end
+      end
+      
+      results
+    end
+    
+  
+    # count of sample (i.e. 'B') that
+    # contains feature (f) but does not belong to class (k)
+    def get_B(f, k)
+      @B ||= calc_B
+      b = @B[k][f]
+          
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      b+=0.5 if b.zero?
+      
+      b
+    end
+    
+    
+    # pre-compute 'B'
+    def calc_B
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          count = 0.0
+          
+          each_sample do |k2, s|
+            if k2 != k1
+              count += 1 if s.has_key? f
+            end
+          end
+          
+          results[k1][f] = count
+        end
+      end
+      
+      results
+    end
+    
+    
+    # count of sample (i.e. 'C') that
+    # does not contain feature (f) but belongs to class (k)
+    def get_C(f, k)
+      @C ||= calc_C
+      c = @C[k][f]
+      
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      c+=0.5 if c.zero?
+      
+      c
+    end
+    
+  
+    # pre-compute 'C'
+    def calc_C
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          count = 0.0
+          
+          each_sample do |k2, s|
+            if k2 == k1
+              count += 1 if not s.has_key? f
+            end
+          end
+          
+          results[k1][f] = count
+        end
+      end
+      
+      results
+    end
+    
+    
+    # count of sample (i.e. 'D') that
+    # does not contain feature (f) and does not belong to class (c)
+    def get_D(f, k)
+      @D ||= calc_D
+      d = @D[k][f]
+      
+      # add 0.5 to avoid any ZERO in denominator or numerator
+      d+=0.5 if d.zero?
+      
+      d
+    end
+
+    
+    # pre-compute 'D'
+    def calc_D
+      results = {}
+      
+      each_class do |k1|
+        results[k1] = {}
+        
+        each_feature do |f|
+          count = 0.0
+          
+          each_sample do |k2, s|
+            if k2 != k1
+              count += 1 if not s.has_key? f
+            end
+          end
+          
+          results[k1][f] = count
+        end
+      end
+      
+      results
+    end
+    
+    
+  end # class
+
+
+end # module

data/lib/fselector/ensemble.rb

@@ -0,0 +1,181 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+  # select feature by an ensemble of ranking algorithms
+  class Ensemble < Base
+    # new()
+    #
+    # @param [Array] rankers multiple feature ranking algorithms
+    def initialize(*algos)
+      super(nil)
+      
+      @algos = []
+      algos.each do |r|
+        @algos << r
+      end
+    end
+    
+    
+    #
+    # reload set\_data
+    #
+    # @note all algos share the same data structure
+    #
+    def set_data(data)
+      super
+      
+      @algos.each do |r|
+        r.set_data(data)
+      end
+    end
+    
+    
+    #
+    # reload get\_feature\_scores
+    #
+    def get_feature_scores
+      return @scores if @scores
+      
+      abort "[#{__FILE__}@#{__LINE__}]: "+
+              "please call one consensus scoring method first!"
+    end
+    
+    
+    #
+    # reload get\_feature\_ranks
+    #
+    def get_feature_ranks
+      return @ranks if @ranks
+      
+      abort "[#{__FILE__}@#{__LINE__}]: "+
+              "please call one consensus ranking method first!"
+    end
+    
+    
+    # ensemble based on score
+    #
+    # @param [Method] by_what by what criterion that ensemble
+    #   score should be obtained from those of individual algorithms  
+    #   allowed values are:  
+    #   receiver.method(:by\_min) # by min rank  
+    #   receiver.method(:by\_max) # by max rank  
+    #   receiver.method(:by\_ave) # by ave rank
+    # @param [Integer] norm normalization  
+    #   :min\_max, score scaled to [0, 1]  
+    #   :zscore, score converted to zscore
+    #
+    # @note scores from different algos are usually incompatible with
+    #   each other, we have to normalize it first
+    #
+    def ensemble_by_score(by_what=method(:by_max), norm=:min_max)
+      @algos.each do |r|
+        if norm == :min_max
+          normalize_min_max!(r)
+        elsif norm == :zscore
+          normalize_zscore!(r)
+        else
+          abort "[#{__FILE__}@#{__LINE__}]: "+
+              "invalid normalizer, only :min_max and :zscore supported!"
+        end
+      end
+      
+      @scores = {}
+      
+      each_feature do |f|
+        @scores[f] = {}
+        @scores[f][:BEST] = by_what.call(
+          @algos.collect { |r| r.get_feature_scores[f][:BEST] }
+        )
+      end      
+    end
+    
+    
+    # ensemble based on rank
+    #
+    # @param [Method] by_what by what criterion that ensemble
+    #   rank should be obtained from those of individual algorithms  
+    #   allowed values are:  
+    #   method(:by\_min) # by min rank  
+    #   method(:by\_max) # by max rank  
+    #   method(:by\_ave) # by ave rank
+    #
+    def ensemble_by_rank(by_what=method(:by_min))
+      ranks = {}
+           
+      each_feature do |f|
+        ranks[f] = by_what.call(
+          @algos.collect { |r| r.get_feature_ranks[f] }
+        )
+      end
+      
+      new_ranks = {}
+      
+      sorted_features = ranks.keys.sort do |x, y|
+        ranks[x] <=> ranks[y]
+      end
+      sorted_features.each_with_index do |sf, si|
+        new_ranks[sf] = si+1
+      end
+      
+      @ranks = new_ranks
+    end
+    
+    
+    # by average value of an array
+    def by_ave(arr)
+      arr.ave if arr.class == Array
+    end
+    
+    
+    # by min value of an array
+    def by_min(arr)
+      arr.min if arr.class == Array
+    end
+    
+    
+    # by max value of an array
+    def by_max(arr)
+      arr.max if arr.class == Array
+    end
+    
+    private
+    
+    #
+    # normalize feature scores of each individual alogrithm (r)
+    # by scaling to [0, 1]
+    #
+    # @note original scores will be altered in place
+    #
+    def normalize_min_max!(r)
+      scores = r.get_feature_scores
+      scores_best = scores.collect { |f, ks|  ks[:BEST] }
+      min, max = scores_best.min, scores_best.max
+      
+      scores.each do |f, ks|
+        ks[:BEST] = (ks[:BEST]-min) / (max-min)
+      end
+    end
+    
+    
+    #
+    # normalize feature scores of each individual alogrithm (r)
+    # by z-score
+    #
+    # @note original scores will be altered in place
+    #
+    def normalize_zscore!(r)
+      scores = r.get_feature_scores
+      scores_best = scores.collect { |f, ks|  ks[:BEST] }
+      ave, sd = scores_best.ave, scores_best.sd
+      
+      scores.each do |f, ks|
+        ks[:BEST] = (ks[:BEST]-ave) / sd
+      end
+    end
+    
+    
+  end # class
+  
+  
+end # module