fselector 0.1.2 → 0.2.0

data/lib/fselector/algo_continuous/Relief_c.rb

@@ -9,96 +9,12 @@ module FSelector
 #
 # ref: [The Feature Selection Problem: Traditional Methods and a New Algorithm](http://www.aaai.org/Papers/AAAI/1992/AAAI92-020.pdf)
 #
-  class Relief_c < BaseContinuous
-    #
-    # new()
-    #
-    # @param [Integer] m number of samples to be used 
-    #   for estimating feature contribution. max can be
-    #   the number of training samples
-    # @param [Hash] data existing data structure
-    #
-    def initialize(m=nil, data=nil)
-      super(data)
-      @m = m # default use all samples
-    end
-    
-    private
-    
-    # calculate contribution of each feature (f) across all classes
-    def calc_contribution(f)
-      if not get_classes.size == 2
-        abort "[#{__FILE__}@#{__LINE__}]: "+
-        "Relief applicable only to two-class problems without missing data"
-      end
-      
-      # use all samples if @m not provided
-      @m = get_sample_size if not @m
-      
-      k1, k2 = get_classes
-      score = 0.0
-      
-      @m.times do
-        # pick a sample at random
-        rs, rk = pick_a_sample_at_random
-        
-        # find the nearest neighbor for each class
-        nbrs = find_nearest_nb(rs, rk)
+  class Relief_c < BaseRelief
         
-        # calc contribution from neighbors
-        score += calc_score(f, rs, rk, nbrs)
-      end
-      
-      s = score / @m
-      
-      set_feature_score(f, :BEST, s)
-    end # calc_contribution
-    
-    
-    # pick a sample at random
-    def pick_a_sample_at_random
-      rk = get_classes[rand(get_classes.size)]
-      rks = get_data[rk]
-      
-      [ rks[rand(rks.size)], rk ]
-    end # pick_a_sample_at_random
-    
-    
-    # find nearest neighbor sample for given sample (rs) within class (k)
-    def find_nearest_nb(rs, rk)
-      nbrs = {}
-      
-      each_class do |k|
-        nb, dmin = nil, 999
-        get_data[k].each do |s|
-          next if s == rs # exclude self
-          d = diff_sample(rs, s)
-          if d < dmin
-            dmin = d
-            nb = s
-          end
-        end
-        
-        nbrs[k] = nb
-      end
-      
-      nbrs
-    end # find_nearest_nb
-    
-    
-    # difference between two samples
-    def diff_sample(s1, s2)
-      d = 0.0
-            
-      each_feature do |f|
-        d += diff_feature(f, s1, s2)**2
-      end
-      
-      d
-    end # diff_sample
-    
+    private
     
     # difference beween the feature (f) of two samples
+    # specialized version for continuous feature
     def diff_feature(f, s1, s2)
       if not s1.has_key?(f) or not s2.has_key?(f)
         abort "[#{__FILE__}@#{__LINE__}]: "+
@@ -126,22 +42,6 @@ module FSelector
     end # get_normalization_unit
     
     
-    # calc feature (f) contribution from neighbors
-    def calc_score(f, rs, rk, nbrs)
-      score = 0.0
-      
-      nbrs.each do |k, s|
-        if k == rk # near hit
-          score -= diff_feature(f, rs, s)**2
-        else # near_miss
-          score += diff_feature(f, rs, s)**2
-        end
-      end
-      
-      score
-    end # calc_score
-    
-    
   end # class
   
   

data/lib/fselector/algo_discrete/CFS_d.rb

@@ -0,0 +1,41 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Correlation-based Feature Selection (CFS) algorithm for discrete feature (CFS_d)
+#
+# ref: [Feature Selection for Discrete and Numeric Class Machine Learning](http://www.cs.waikato.ac.nz/ml/publications/1999/99MH-Feature-Select.pdf)
+#
+  class CFS_d < BaseCFS
+    # include Entropy module
+    include Entropy
+    
+    private
+        
+    # calc the feature-class correlation of two vectors
+    def do_rcf(cv, fv)
+      hc = get_marginal_entropy(cv)
+      hf = get_marginal_entropy(fv)
+      hcf = get_conditional_entropy(cv, fv)
+      
+      # symmetrical uncertainty
+      2*(hc-hcf)/(hc+hf)
+    end # do_rcf
+    
+    
+    # calc the feature-feature correlation of two vectors
+    def do_rff(fv, sv)
+      hf = get_marginal_entropy(fv)
+      hs = get_marginal_entropy(sv)
+      hfs = get_conditional_entropy(fv, sv)
+      
+      # symmetrical uncertainty
+      2*(hf-hfs)/(hf+hs)
+    end # do_rff
+    
+    
+  end # class
+  
+  
+end # module

data/lib/fselector/algo_discrete/FastCorrelationBasedFilter.rb

@@ -66,7 +66,7 @@ module FSelector
       end
       
       subset
-    end
+    end # get_feature_subset
     
     
     # SU(X,Y) = 2 * ( H(X)-H(X|Y) ) / ( H(X)+H(Y) )

data/lib/fselector/algo_discrete/InformationGain.rb

@@ -14,15 +14,28 @@ module FSelector
 # ref: [Using Information Gain to Analyze and Fine Tune the Performance of Supply Chain Trading Agents](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.141.7895)
 #
   class InformationGain < BaseDiscrete
+    # include entropy module
+    include Entropy
 
     private
   
     # calculate contribution of each feature (f) across all classes
     # see entropy-related functions in BaseDiscrete
     def calc_contribution(f)
-      hc, hcf = get_Hc, get_Hcf(f)
+      # cache H(c)
+      if not @hc
+        cv = get_class_labels
+        @hc = get_marginal_entropy(cv)
+      end
       
-      s =  hc - hcf
+      # H(c|f)
+      # collect class labels (cv) and feature values (fv)
+      cv = get_class_labels
+      fv = get_feature_values(f, :include_missing_values)
+      hcf = get_conditional_entropy(cv, fv)
+      
+      # information gain
+      s =  @hc - hcf
       
       set_feature_score(f, :BEST, s)      
     end # calc_contribution 

data/lib/fselector/algo_discrete/ReliefF_d.rb

@@ -8,90 +8,12 @@ module FSelector
 #
 # ref: [Estimating Attributes: Analysis and Extensions of RELIEF](http://www.springerlink.com/content/fp23jh2h0426ww45/)
 #
-  class ReliefF_d < BaseDiscrete
-    #
-    # new()
-    #
-    # @param [Integer] m number of samples to be used 
-    #   for estimating feature contribution. max can be
-    #   the number of training samples
-    # @param [Integer] k number of k-nearest neighbor
-    # @param [Hash] data existing data structure
-    #
-    def initialize(m=nil, k=10, data=nil)
-      super(data)
-      @m = m # use all samples
-      @k = (k || 10)  # default 10
-    end
-    
-    private
-    
-    # calculate contribution of each feature (f) across all classes
-    def calc_contribution(f)      
-      score = 0.0
-      
-      # use all samples if @m not provided
-      @m = get_sample_size if not @m
-      
-      @m.times do
-        # pick a sample at random
-        rs, rk = pick_a_sample_at_random
-        
-        # find k nearest neighbor for each class
-        nbrs = find_k_nearest_nb(rs, rk)
-        
-        # calc contribution from neighbors
-        score += calc_score(f, rs, rk, nbrs)
-      end
-      
-      s = score / @m
-      
-      set_feature_score(f, :BEST, s)
-    end # calc_contribution
-    
-    
-    # pick a sample at random
-    def pick_a_sample_at_random
-      rk = get_classes[rand(get_classes.size)]
-      rks = get_data[rk]
-      
-      [ rks[rand(rks.size)], rk ]
-    end # pick_a_sample_at_random
-    
-    # # find k nearest neighbors of sample (rs) for each class 
-    def find_k_nearest_nb(rs, rk)
-      nbrs = {}
-      
-      each_class do |k|
-        res = []
+  class ReliefF_d < BaseReliefF
         
-        get_data[k].each do |s|
-          next if s == rs # exclude self
-          
-          d = diff_sample(rs, s, rk, k)
-          res << [d, s]
-        end
-        
-        nbrs[k] = (res.sort { |x, y| x[0] <=> y[0] }[0...@k]).collect { |z| z[1] }
-      end
-      
-      nbrs
-    end # find_k_nearest_nb
-    
-    
-    # difference between two samples
-    def diff_sample(s1, s2, k1, k2)
-      d = 0.0
-            
-      each_feature do |f|
-        d += diff_feature(f, s1, s2, k1, k2)**2
-      end
-      
-      d
-    end # diff_sample
-    
+    private
     
     # difference beween the feature (f) of two samples
+    # specialized version for discrete feature
     def diff_feature(f, s1, s2, k1, k2)
       d = 0.0
       
@@ -115,57 +37,6 @@ module FSelector
     end # diff_feature
     
     
-    # calc probability of missing value (mv)
-    def calc_p(f, mv, k) 
-      # cache
-      if not @f2mvp
-        @f2mvp = {}
-        
-        each_feature do |f|
-          @f2mvp[f] = {}
-          
-          each_class do |k|
-            @f2mvp[f][k] = {}
-            
-            fvs = get_feature_values(f).uniq
-            fvs.each do |v|
-              n = 0.0
-              
-              get_data[k].each do |s|
-                n += 1 if s.has_key?(f) and s[f] == v
-              end
-              
-              @f2mvp[f][k][v] = n/get_data[k].size
-            end
-          end
-        end
-      end
-      
-      @f2mvp[f][k][mv]
-    end
-    
-    
-    # calc feature (f) contribution from neighbors
-    def calc_score(f, rs, rk, nbrs)
-      score = 0.0
-      
-      nbrs.each do |k, nbs|
-        if k == rk # near hit
-          nbs.each do |s|
-            score -= (diff_feature(f, rs, s, rk, k)**2/nbs.size)
-          end
-        else # near_miss
-          nbs.each do |s|
-            score += (get_data[k].size/get_sample_size.to_f *
-                     diff_feature(f, rs, s, rk, k)**2/nbs.size)
-          end
-        end
-      end
-      
-      score
-    end
-    
-    
   end # class
   
   

data/lib/fselector/algo_discrete/Relief_d.rb

@@ -9,96 +9,12 @@ module FSelector
 #
 # ref: [The Feature Selection Problem: Traditional Methods and a New Algorithm](http://www.aaai.org/Papers/AAAI/1992/AAAI92-020.pdf)
 #
-  class Relief_d < BaseDiscrete
-    #
-    # new()
-    #
-    # @param [Integer] m number of samples to be used 
-    #   for estimating feature contribution. max can be
-    #   the number of training samples
-    # @param [Hash] data existing data structure
-    #
-    def initialize(m=nil, data=nil)
-      super(data)
-      @m = m # default use all samples
-    end
-    
-    private
-    
-    # calculate contribution of each feature (f) across all classes
-    def calc_contribution(f)
-      if not get_classes.size == 2
-        abort "[#{__FILE__}@#{__LINE__}]: "+
-        "Relief applicable only to two-class problems without missing data"
-      end
-      
-      # use all samples if @m not provided
-      @m = get_sample_size if not @m
-      
-      k1, k2 = get_classes
-      score = 0.0
-      
-      @m.times do        
-        # pick a sample at random
-        rs, rk = pick_a_sample_at_random
-        
-        # find the nearest neighbor for each class
-        nbrs = find_nearest_nb(rs, rk)
-        
-        # calc contribution from neighbors
-        score += calc_score(f, rs, rk, nbrs)
-      end
-      
-      s = score / @m
-      
-      set_feature_score(f, :BEST, s)
-    end # calc_contribution
-    
-    
-    # pick a sample at random
-    def pick_a_sample_at_random
-      rk = get_classes[rand(get_classes.size)]
-      rks = get_data[rk]
-      
-      [ rks[rand(rks.size)], rk ]
-    end # pick_a_sample_at_random
-    
-    
-    # find nearest neighbor sample for given sample (rs) within class (k)
-    def find_nearest_nb(rs, rk)
-      nbrs = {}
-      
-      each_class do |k|
-        nb, dmin = nil, 999
-        get_data[k].each do |s|
-          next if s == rs # exclude self
-          d = diff_sample(rs, s)
-          if d < dmin
-            dmin = d
-            nb = s
-          end
-        end
-        
-        nbrs[k] = nb
-      end
-      
-      nbrs
-    end # find_nearest_nb
-    
-    
-    # difference between two samples
-    def diff_sample(s1, s2)
-      d = 0.0
-      
-      each_feature do |f|
-        d += diff_feature(f, s1, s2)**2
-      end
-      
-      d
-    end # diff_sample
+  class Relief_d < BaseRelief
     
+    private    
     
     # difference beween the feature (f) of two samples
+    # specialized version for discrete feature
     def diff_feature(f, s1, s2)
       d = 0.0
       
@@ -111,22 +27,6 @@ module FSelector
     end # diff_feature
     
     
-    # calc feature (f) contribution from neighbors
-    def calc_score(f, rs, rk, nbrs)
-      score = 0.0
-      
-      nbrs.each do |k, s|
-        if k == rk # near hit
-          score -= diff_feature(f, rs, s)**2
-        else # near_miss
-          score += diff_feature(f, rs, s)**2
-        end
-      end
-      
-      score
-    end # calc_score
-    
-    
   end # class