fselector 0.9.0 → 1.0.0

data/lib/fselector/algo_discrete/LasVegasIncremental.rb

@@ -8,12 +8,15 @@ module FSelector
 #
 # ref: [Incremental Feature Selection](http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.8218)
 #
-  class LasVegasIncremental < BaseDiscrete    
+  class LasVegasIncremental < BaseDiscrete
+    # include Consistency module
+    include Consistency
+    
     #
-    # initialize from existing data structure
+    # initialize from an existing data structure
     # 
     # @param [Integer] max_iter maximum number of iterations
-    # @param [Hash] data existing data structure
+    # @param [Float] portion percentage of data used by LVF
     #
     def initialize(max_iter=100, portion=0.10, data=nil)
       super(data)
@@ -21,31 +24,36 @@ module FSelector
       @portion = portion || 0.10
     end
     
-    private
+    private    
     
     # Las Vegas Incremental (LVI) algorithm
     def get_feature_subset
       data = get_data # working dataset
       s0, s1 = portion(data)
-      feats = get_features # initial best solution
-      j0 = check_incon_rate(data, feats)[0] # initial data inconsistency rate
+      feats = get_features
+      j0 = get_IR(data) # initial data inconsistency rate
+      
+      # instead of s0 and s1, we play with their inst_cnt Hash tables
+      inst_cnt_s0 = get_instance_count(s0)
+      inst_cnt_s1 = get_instance_count(s1)
       
       subset = feats # initial feature subset
       
       while true
-        f_try = lvf(s0, feats, j0) # keep only one equivalently good subset
+        j_s0, f_try = lvf(inst_cnt_s0, feats, j0) # keep only one equivalently good subset
         #pp f_try
+        #s = inst_cnt_s0.merge(inst_cnt_s1) { |kk, v1, v2| v1.merge(v2) {|vv,x1,x2| x1+x2 }  }
+        #pp s==get_instance_count
         
-        j_s0 = check_incon_rate(s0, f_try)[0]
-        j_s1, inconC = check_incon_rate(s1, f_try)
+        j_s1, inconC = check_incon_rate(inst_cnt_s1, f_try)
         
-        #pp [j0, j_s0, j_s1, s0.values.flatten.size, s1.values.flatten.size, f_try.size]
+        #pp [j0, j_s0, j_s1, count(inst_cnt_s0), count(inst_cnt_s1), f_try.size]
         
-        if j_s0+j_s1 <= j0 or inconC.empty?
+        if j_s0+j_s1 <= j0 # or inconC.empty?
           subset = f_try
           break
         else
-          update(s0, s1, inconC)
+          update(inst_cnt_s0, inst_cnt_s1, inconC)
         end
       end
       
@@ -72,103 +80,87 @@ module FSelector
     end
     
     # check evaluation mean J -> (0, 1]
-    def check_incon_rate(data, feats)
+    def check_incon_rate(inst_cnt, feats)
       #pp feats
       ir, inconC = 0.0, []
       
-      # create a reduced dataset within feats
-      dt = {}
-      data.each do |k, ss|
-        dt[k] ||= []
-        ss.each do |s|
-          my_s = s.select { |f,v| feats.include? f }
-          dt[k] << my_s if not my_s.empty?
-        end
+      # build new inst_count for feats
+      inst_cnt_new = {}
+      k2k = {} # map of key_old to key_new
+
+      inst_cnt.each do |key, hcnt|
+        key_new = feats.sort.collect { |f|
+          match_data = key.match(/#{f}:.*?\|/)
+          match_data[0] if match_data
+        }.compact.join # remove nil entry and join
+        next if key_new.empty?
+        
+        k2k[key] = key_new
+        
+        hcnt_new = inst_cnt_new[key_new] || Hash.new(0)
+        # merge cnts
+        inst_cnt_new[key_new] = hcnt_new.merge(hcnt) { |kk, v1, v2| v1+v2 }
       end
+
+      ir = get_IR_by_count(inst_cnt_new)
       
-      # check data inconsistency rate
-      # get unique instances (except class label)
-      inst_u = dt.values.flatten.uniq
-      inst_u_cnt = {} # occurrences for each unique instance in each class
-      ks = dt.keys
-      
-      # count
-      inst_u.each_with_index do |inst, idx|
-        inst_u_cnt[idx] = [] # record for all classes
-        ks.each do |k|
-          inst_u_cnt[idx] << dt[k].count(inst)
-        end
-      end
-     
-      # inconsistency count
-      inconsis = 0.0
-      inst_u_cnt.each do |idx, cnts|
-        diff = cnts.sum-cnts.max
-        inconsis += diff
+      # check inconsistency instances
+      inst_cnt.keys.each do |key|
+        next if not k2k.has_key? key
+        
+        key_new = k2k[key]
         
-        if not diff.zero? # inconsistent instance
-          inconC << inst_u[idx]
+        cnt_new = inst_cnt_new[key_new].values
+        if cnt_new.sum-cnt_new.max > 0 # inconsistency
+          inconC << key
         end
       end
       
-      # inconsistency rate
-      sz = dt.values.flatten.size # inconsis / num_of_sample
-      ir = inconsis/sz if not sz.zero?
-      
       [ir, inconC]
     end
     
     
     # lvf
-    def lvf(data, feats, j0)
+    def lvf(inst_cnt, feats, j0)
       subset_best = feats
       sz_best = subset_best.size
+      j_best = j0
       
       @max_iter.times do
         # always sample a smaller feature subset than sz_best at random
         f_try = feats.sample(rand(sz_best-1)+1)
+        j_try = get_IR_by_feature(inst_cnt, f_try)
         
-        if check_incon_rate(data, f_try)[0] <= j0
+        if j_try <= j0
           subset_best = f_try
-          sz_best = f_try.size
+          sz_best = subset_best.size
+          j_best = j_try
         end
       end
       
-      subset_best
-    end
+      [j_best, subset_best]
+    end # lvf
     
     
-    # update s0, s1
-    def update(s0, s1, inconC)      
-      inconC.each do |inst|
-        s1.each do |k, sams|
-          sams.each_with_index do |sam, i|
-            if is_subset?(inst, sam)
-              s0[k] << sam
-              sams[i] = nil
-            end
-          end
-          
-          sams.compact!
-        end
+    # update inst_cnt_s0, inst_cnt_s1
+    def update(inst_cnt_s0, inst_cnt_s1, inconC)      
+      inconC.each do |inst_key|
+        hcnt_s0 = inst_cnt_s0[inst_key] ||= Hash.new(0)
+        hcnt_s1 = inst_cnt_s1[inst_key]
+        
+        inst_cnt_s0[inst_key] = hcnt_s0.merge(hcnt_s1) { |kk, v1, v2| v1+v2 }
+        # remove from inst_cnt_s0
+        inst_cnt_s1.delete(inst_key)
       end
-    end
-    
+    end # update
     
-    # is Hash a is a subset of Hash b
-    def is_subset?(ha, hb)
-      ha.each do |k, v|
-        if hb.has_key? k and v == hb[k]
-          next
-        else
-          return false
-        end
-      end
-      
-      return true
-    end
     
+    # the number of instances
+    def count(inst_cnt)
+      inst_cnt.values.collect { |hcnt| hcnt.values.sum }.sum
+    end # count
     
+        
   end # class
   
   

data/lib/fselector/algo_discrete/MatthewsCorrelationCoefficient.rb

@@ -9,9 +9,9 @@ module FSelector
 #     MCC = ---------------------------------------------- = PHI = sqrt(CHI/N)
 #            sqrt((tp+fp) * (tp+fn) * (tn+fp) * (tn+fn) )
 #     
-#                          A*D - B*C
+#                         A*D - B*C
 #         = -------------------------------------
-#           sqrt((A+B) * (A+C) * (B+D) * (C+D))
+#            sqrt((A+B) * (A+C) * (B+D) * (C+D))
 #
 # ref: [Wikipedia](http://en.wikipedia.org/wiki/Matthews_correlation_coefficient)
 #
@@ -25,9 +25,9 @@ module FSelector
         a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
         
         s = 0.0
-        if not ((a+b)*(a+c)*(b+d)*(c+d)).zero?     
-          s = (a*d-b*c) / Math.sqrt((a+b)*(a+c)*(b+d)*(c+d))
-        end
+        x = (a+b)*(a+c)*(b+d)*(c+d)
+        
+        s = (a*d-b*c) / Math.sqrt(x) if not x.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/McNemarsTest.rb

@@ -2,11 +2,12 @@
 # FSelector: a Ruby gem for feature selection and ranking
 #
 module FSelector
+#
 # McNemar's test (MNT), based on Chi-Squared test
 #
-#                 (B-C)^2
-#     MNT(f, c) = ---------
-#                  B+C
+#            (B-C)^2
+#     MNT = ---------
+#              B+C
 #
 # suitable for large samples and B+C >= 25
 #
@@ -14,12 +15,12 @@ module FSelector
 #
   class McNemarsTest < BaseDiscrete
     #
-    # new()
+    # intialize from an existing data structure
     #
-    # @param [Boolean] correction Yates's continuity correction?  
-    #   no correction if nil, correction otherwise
+    # @param [Boolean] correction use Yates's continuity correction if :yates, 
+    #   no correction otherwise
     #
-    def initialize(correction=nil, data=nil)
+    def initialize(correction=:yates, data=nil)
       super(data)
       @correction = (correction==:yates) ? true : false
     end
@@ -37,11 +38,13 @@ module FSelector
         end
         
         s = 0.0
-        if not (b+c).zero?
+        x = b+c
+        
+        if not x.zero?
           if not @correction
-            s = (b-c)**2 / (b+c)
+            s = (b-c)**2 / x
           else
-            s = ((b-c).abs-0.5)**2 / (b+c)
+            s = ((b-c).abs-0.5)**2 / x
           end
         end
         

data/lib/fselector/algo_discrete/MutualInformation.rb

@@ -5,7 +5,7 @@ module FSelector
 #
 # Mutual Information (MI)
 #
-#                       P(f, c)
+#                       P(f,c)
 #     MI(f,c) = log2 -------------
 #                     P(f) * P(c)
 #     
@@ -26,9 +26,9 @@ module FSelector
         n = a+b+c+d
         
         s = 0.0
-        if not ((a+b)*(a+c)).zero?
-          s = Math.log2(a*n/(a+b)/(a+c))
-        end
+        x = (a+b)*(a+c)
+        
+        s = Math.log2(a*n/x) if not x.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/OddsRatio.rb

@@ -25,9 +25,9 @@ module FSelector
         a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
         
         s = 0.0
-        if not (b*c).zero?
-          s = (a*d) / (b*c)
-        end
+        x = b*c
+        
+        s = (a*d) / x if not x.zero?
             
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/OddsRatioNumerator.rb

@@ -7,7 +7,7 @@ module FSelector
 #
 #     OddN(f,c) = P(f|c) * (1 - P(f|c')) =  tpr * (1-fpr)
 #     
-#                   A           B           A*D
+#                   A           B          A * D
 #               = ---- * (1 - ----) = ---------------
 #                  A+C         B+D     (A+C) * (B+D)
 #
@@ -23,9 +23,9 @@ module FSelector
         a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
         
         s = 0.0
-        if not ((a+c)*(b+d)).zero?
-          s = a*d/(a+c)/(b+d)
-        end
+        x = (a+c)*(b+d)
+        
+        s = a*d/x if not x.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/Power.rb

@@ -3,22 +3,21 @@
 #
 module FSelector
 #
-# Power (pow)
+# Power
 #
-#     Pow = (1-fpr)^k - (1-tpr)^k
+#     Power = (1-fpr)^k - (1-tpr)^k
 #     
-#         = (1-B/(B+D))^k - (1-A/(A+C))^k
+#           = (1-B/(B+D))^k - (1-A/(A+C))^k
 #     
-#         = (D/(B+D))^k - (C/(A+C))^k
+#           = (D/(B+D))^k - (C/(A+C))^k
 #
 # ref: [An extensive empirical study of feature selection metrics for text classification](http://dl.acm.org/citation.cfm?id=944974)
 #
   class Power < BaseDiscrete    
     #
-    # initialize from existing data structure
+    # initialize from an existing data structure
     # 
     # @param [Integer] k power
-    # @param [Hash] data existing data structure
     #
     def initialize(k=5, data=nil)
       super(data)
@@ -33,9 +32,9 @@ module FSelector
         a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
         
         s = 0.0
-        if not (b+d).zero? and not (a+c).zero?
-          s = (d/(b+d))**(@k) - (c/(a+c))**(@k)
-        end
+        x, y = b+d, a+c
+        
+        s = (d/x)**(@k) - (c/y)**(@k) if not x.zero? and not y.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/Precision.rb

@@ -19,9 +19,9 @@ module FSelector
         a, b = get_A(f, k), get_B(f, k)
         
         s = 0.0
-        if not (a+b).zero?
-          s = a/(a+b)
-        end
+        x = a+b
+        
+        s = a/x if not x.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/ProbabilityRatio.rb

@@ -23,9 +23,9 @@ module FSelector
         a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
         
         s = 0.0
-        if not (a+c).zero? and not b.zero?
-          s = a * (b+d) / (a+c) / b
-        end
+        x = (a+c)*b
+        
+        s = a * (b+d) / x if not x.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/Sensitivity.rb

@@ -21,9 +21,9 @@ module FSelector
         a, c = get_A(f, k), get_C(f, k)
         
         s =0.0
-        if not (a+c).zero?
-          s = a/(a+c)
-        end
+        x = a+c
+        
+        s = a/x if not x.zero?
         
         set_feature_score(f, k, s)
       end

data/lib/fselector/algo_discrete/Specificity.rb

@@ -21,9 +21,9 @@ module FSelector
         b, d = get_B(f, k), get_D(f, k)
         
         s = 0.0
-        if not (b+d).zero?
-          s = d/(b+d)
-        end
+        x = b+d
+        
+        s = d/x if not x.zero?
         
         set_feature_score(f, k, s)
       end