fselector 0.1.0

data/lib/fselector/algo_discrete/InformationGain.rb

@@ -0,0 +1,96 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Information Gain for feature with discrete data (IG)
+#
+#     IG_d(c,f) = H(c) - H(c|f)
+#     
+#     where H(c) = -1 * sigma_i (P(ci) logP(ci))
+#           H(c|f) = sigma_j (P(fj)*H(c|fj))
+#           H(c|fj) = -1 * sigma_k (P(ck|fj) logP(ck|fj))
+#
+# ref: [Using Information Gain to Analyze and Fine Tune
+#      the Performance of Supply Chain Trading Agents][url]
+# [url]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.141.7895
+#
+  class InformationGain < BaseDiscrete
+
+    private
+  
+    # calculate contribution of each feature (f) across all classes
+    def calc_contribution(f)
+      # H(c)
+      hc = 0.0
+      n = get_sample_size.to_f
+      
+      each_class do |k|
+        nk = get_data[k].size
+        p1 = nk/n
+
+        if p1.zero?
+          hc += -0.0
+        else
+          hc += -1.0 * ( p1 * Math.log2(p1) )
+        end
+      end
+      
+      # H(c|f)
+      hcf = 0.0
+      m = {}
+      
+      each_class do |k|
+        nk = get_data[k].size        
+        nv = 0.0
+        
+        fvs = get_feature_values(f).uniq
+        fvs.each do |v|
+          a, b = get_Av(f, k, v), get_Bv(f, k, v)
+          #pp "(v,a,b) => (#{v}, #{a}, #{b})"
+          nv += a
+          
+          p2 = a/(a+b)
+          p3 = (a+b)/n
+          
+          if p2.zero?
+            hcf += -0.0
+          else
+            hcf += -1.0 * p3 * (p2 * Math.log2(p2))
+          end           
+        end
+        
+        m[k] = nk - nv
+         
+      end
+      
+      # handle empty feature for each class
+      sm = m.values.sum
+      if not sm.zero?
+        #pp m
+        m.each do |k, i|
+          pm = i/sm
+          
+          if pm.zero?
+            hcf += -0.0
+          else
+            hcf += -1.0 * (sm/n) * (pm * Math.log2(pm))
+          end
+        end
+      end
+      
+      # IG
+     s =  hc - hcf
+     
+     set_feature_score(f, :BEST, s)      
+    end # calc_contribution
+    
+      	
+  end # class 
+ 
+    
+  # shortcut so that you can use FSelector::IG instead of FSelector::InformationGain
+  IG = InformationGain
+  
+  
+end # module

data/lib/fselector/algo_discrete/MatthewsCorrelationCoefficient.rb

@@ -0,0 +1,45 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Matthews Correlation Coefficient (MCC)
+#  
+#                            tp*tn - fp*fn
+#     MCC = ---------------------------------------------- = PHI = sqrt(CHI/N)
+#            sqrt((tp+fp) * (tp+fn) * (tn+fp) * (tn+fn) )
+#     
+#                          A*D - B*C
+#         = -------------------------------------
+#           sqrt((A+B) * (A+C) * (B+D) * (C+D))
+#
+# ref: [Wikipedia][wiki]
+# [wiki]: http://en.wikipedia.org/wiki/Matthews_correlation_coefficient
+#
+  class MatthewsCorrelationCoefficient < BaseDiscrete
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        n = a+b+c+d
+      
+        s = (a*d-b*c) / Math.sqrt((a+b)*(a+c)*(b+d)*(c+d))
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::MCC instead of FSelector::MatthewsCorrelationCoefficient
+  MCC = MatthewsCorrelationCoefficient
+  # Matthews Correlation Coefficient (MCC), also known as Phi coefficient 
+  PHI = MatthewsCorrelationCoefficient
+  
+  
+end # module

data/lib/fselector/algo_discrete/McNemarsTest.rb

@@ -0,0 +1,57 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+# McNemar's test (MN), based on Chi-Squared test
+#
+#                 (B-C)^2
+#     MN(f, c) = ---------
+#                  B+C
+#
+# suitable for large samples and B+C >= 25
+#
+# ref: [Wikipedia](http://en.wikipedia.org/wiki/McNemar%27s_test)
+#
+  class McNemarsTest < BaseDiscrete
+    #
+    # new()
+    #
+    # @param [Boolean] correction correction Yates's continuity correction  
+    #   :yates, Yates's continuity correction
+    #
+    def initialize(correction=nil, data=nil)
+      super(data)
+      @correction = (correction==:yates) ? true : false
+    end
+     
+    private
+        
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        b, c = get_B(f, k), get_C(f, k)
+        
+        if b+c < 25
+          $stderr.puts "McNemarsTest [warning]:\n  " +
+            "Chi-squared approximation may be incorrect"
+        end
+        
+        if not @correction
+          s = (b-c)**2 / (b+c)
+        else
+          s = ((b-c).abs-0.5)**2 / (b+c)
+        end
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::MNT instead of FSelector::McNemarsTest
+  MNT = McNemarsTest
+  
+  
+end # module

data/lib/fselector/algo_discrete/MutualInformation.rb

@@ -0,0 +1,42 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Mutual Information (MI)
+#
+#                       P(f, c)
+#     MI(f,c) = log2 -------------
+#                     P(f) * P(c)
+#     
+#                         A * N
+#             = log2 ---------------
+#                     (A+B) * (A+C)
+#
+# ref: [A Comparative Study on Feature Selection Methods for Drug 
+#      Discovery](http://pubs.acs.org/doi/abs/10.1021/ci049875d)
+#
+  class MutualInformation < BaseDiscrete
+        
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+        each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        n = a+b+c+d
+        
+        s = Math.log2(a*n/(a+b)/(a+c))
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::MI instead of FSelector::MutualInformation
+  MI = MutualInformation
+  
+  
+end # module

data/lib/fselector/algo_discrete/OddsRatio.rb

@@ -0,0 +1,46 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Odds Ratio (Odd)
+#
+#                P(f|c) * (1 - P(f|c'))     tpr * (1-fpr)
+#     Odd(f,c) = ----------------------- = ---------------
+#                (1 - P(f|c)) * P(f|c')     (1-tpr) * fpr
+#     
+#                 A*D
+#              = -----
+#                 B*C
+#
+# ref: [Wikipedia][wiki] and [An extensive empirical study of feature selection
+#       metrics for text classification][url1] and [Optimally Combining Positive
+#       and Negative Features for Text Categorization][url2]
+# [wiki]: http://en.wikipedia.org/wiki/Odds_ratio
+# [url1]: http://dl.acm.org/citation.cfm?id=944974
+# [url2]: http://www.site.uottawa.ca/~nat/Workshop2003/zheng.pdf
+#
+  class OddsRatio < BaseDiscrete
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        
+        s = (a*d) / (b*c)
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::Odd instead of FSelector::OddsRatio
+  Odd = OddsRatio
+  
+  
+end # module

data/lib/fselector/algo_discrete/OddsRatioNumerator.rb

@@ -0,0 +1,41 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Odds Ratio Numerator (OddN)
+#
+#     OddN(f,c) = P(f|c) * (1 - P(f|c')) =  tpr * (1-fpr)
+#     
+#                   A           B           A*D
+#               = ---- * (1 - ----) = ---------------
+#                  A+C         B+D     (A+C) * (B+D)
+#
+# ref: [An extensive empirical study of feature selection metrics
+#       for text classification][url]
+# [url]: http://dl.acm.org/citation.cfm?id=944974
+#
+  class OddsRatioNumerator < BaseDiscrete
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        
+        s = a*d/(a+c)/(b+d)
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::OddN instead of FSelector::OddsRatioNumerator
+  OddN = OddsRatioNumerator
+  
+  
+end # module

data/lib/fselector/algo_discrete/Power.rb

@@ -0,0 +1,46 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Power (pow)
+#
+#     Pow = (1-fpr)^k - (1-tpr)^k
+#     
+#         = (1-B/(B+D))^k - (1-A/(A+C))^k
+#     
+#         = (D/(B+D))^k - (C/(A+C))^k
+#
+# ref: [An extensive empirical study of feature selection metrics
+#       for text classification][url]
+# [url]: http://dl.acm.org/citation.cfm?id=944974
+#
+  class Power < BaseDiscrete    
+    #
+    # new()
+    # 
+    # @param [Integer] k power
+    #
+    def initialize(k=5, data=nil)
+      super(data)
+      @k = k
+    end
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        
+        s = (d/(b+d))**(@k) - (c/(a+c))**(@k)
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+end # module

data/lib/fselector/algo_discrete/Precision.rb

@@ -0,0 +1,31 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Precision
+#
+#                   TP        A
+#     Precision = ------- = -----
+#                  TP+FP     A+B
+#
+  class Precision < BaseDiscrete
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b = get_A(f, k), get_B(f, k)
+        
+        s = a/(a+b)
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+end # module

data/lib/fselector/algo_discrete/ProbabilityRatio.rb

@@ -0,0 +1,41 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Probability Ratio (PR)
+#
+#     PR = tpr / fpr
+#     
+#           A/(A+C)    A * (B+D)
+#        = -------- = -----------
+#           B/(B+D)    (A+C) * B
+#
+# ref: [An extensive empirical study of feature selection metrics
+#       for text classification][url]
+# [url]: http://dl.acm.org/citation.cfm?id=944974
+#
+  class ProbabilityRatio < BaseDiscrete
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        
+        s = a * (b+d) / (a+c) / b
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::PR instead of FSelector::ProbabilityRatio
+  PR = ProbabilityRatio
+  
+  
+end # module