fselector 0.1.0

data/lib/fselector/algo_discrete/Accuracy.rb

@@ -0,0 +1,35 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Accuracy (Acc)
+#
+#               tp+tn          A+D
+#     Acc = ------------- = ---------
+#            tp+fn+tn+fp     A+B+C+D
+#
+  class Accuracy < 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+b+c+d)
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::Acc instead of FSelector::Accuracy
+  Acc = Accuracy
+  
+  
+end # module

data/lib/fselector/algo_discrete/AccuracyBalanced.rb

@@ -0,0 +1,37 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Accuracy Balanced (Acc2)
+#
+#     Acc2 = |tpr - fpr| = |A/(A+C) - B/(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 AccuracyBalanced < 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/(a+c) - b/(b+d)).abs
+        
+        set_feature_score(f, k, s)
+      end
+    end
+    
+    
+  end
+  
+  
+  # shortcut so that you can use FSelector::Acc2 instead of FSelector::AccuracyBalanced
+  Acc2 = AccuracyBalanced
+  
+  
+end

data/lib/fselector/algo_discrete/BiNormalSeparation.rb

@@ -0,0 +1,45 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Bi-Normal Separation (BNS)
+#
+#     BNS = |F'(tpr) - F'(fpr)|
+#      
+#     where F' is normal inverse cumulative distribution function
+#     R executable is required to calculate qnorm, i.e. F'(x)
+# 
+# ref: [An extensive empirical study of feature selection metrics
+#      for text classification](http://dl.acm.org/citation.cfm?id=944974)
+#      and [Rubystats](http://rubystats.rubyforge.org)
+#
+  class BiNormalSeparation < BaseDiscrete
+    # include Ruby statistics libraries
+    include Rubystats
+        
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      @nd ||= Rubystats::NormalDistribution.new
+      
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        
+        tpr, fpr = a/(a+c), b/(b+d)
+        s = (@nd.get_icdf(tpr) - @nd.get_icdf(fpr)).abs
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::BNS instead of FSelector::BiNormalSeparation
+  BNS = BiNormalSeparation
+  
+  
+end # module

data/lib/fselector/algo_discrete/ChiSquaredTest.rb

@@ -0,0 +1,69 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Chi-Squared test (CHI)
+#
+#                  N * ( P(f,c) * P(f',c') - P(f,c') * P(f',c) )^2
+#      CHI(f,c) = -------------------------------------------------
+#                           P(f) * P(f') * P(c) * P(c')
+#      
+#                        N * (A*D - B*C)^2
+#               = -------------------------------
+#                  (A+B) * (C+D) * (A+C) * (B+D)
+#
+# suitable for large samples and
+# none of the values of (A, B, C, D) < 5
+#
+# ref: [Wikipedia](http://en.wikipedia.org/wiki/Chi-squared_test)
+#      and [A Comparative Study on Feature Selection Methods for
+#      Drug Discovery] (http://pubs.acs.org/doi/abs/10.1021/ci049875d)
+#
+  class ChiSquaredTest < BaseDiscrete
+    #
+    # new()
+    #
+    # @param [Boolean] 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|
+        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
+        
+        if a<5 or b<5 or c<5 or d<5
+          $stderr.puts "ChiSquaredTest [warning]:\n  " +
+            "Chi-squared approximation may be incorrect"
+        end
+        
+        if not @correction
+          s = n * ((a*d-b*c)**2) /
+            (a+b) / (c+d) / (a+c) / (b+d)
+        else
+          s = n * (((a*d-b*c).abs - n/2))**2 /
+            (a+b) / (c+d) / (a+c) / (b+d)
+        end
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::CHI instead of FSelector::ChiSquaredTest
+  CHI = ChiSquaredTest
+  
+  
+end # module

data/lib/fselector/algo_discrete/CorrelationCoefficient.rb

@@ -0,0 +1,42 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Correlation Coefficient (CC), a variant of CHI, 
+# which can be viewed as a one-sided chi-squared metric
+#
+#                       sqrt(N) * (A*D - B*C)
+#     CC(f,c) = --------------------------------------
+#                sqrt( (A+B) * (C+D) * (A+C) * (B+D) )
+#
+# ref: [Optimally Combining Positive and Negative Features for 
+#       Text Categorization][url]
+# [url]: http://www.site.uottawa.ca/~nat/Workshop2003/zheng.pdf
+#
+  class CorrelationCoefficient < 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.sqrt(n) * (a*d-b*c) /
+          Math.sqrt( (a+b) * (c+d) * (a+c) * (b+d) )
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::CC instead of FSelector::CorrelationCoefficient
+  CC = CorrelationCoefficient
+  
+  
+end # module

data/lib/fselector/algo_discrete/DocumentFrequency.rb

@@ -0,0 +1,36 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Document Frequency (DF)
+#
+#     DF = tp+fp = (A+B)
+#
+# ref: [An extensive empirical study of feature selection metrics
+#      for text classification] (http://dl.acm.org/citation.cfm?id=944974)
+#
+  class DocumentFrequency < 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 + b
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::DF instead of FSelector::DocumentFrequency
+  DF = DocumentFrequency
+  
+  
+end # module

data/lib/fselector/algo_discrete/F1Measure.rb

@@ -0,0 +1,41 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# F1-Measure (F1)
+#
+#           2 * recall * precision
+#     F1 = ------------------------
+#              recall + precison
+#     
+#                2 * tp               2 * A
+#        = ------------------- = --------------
+#           tp + fn + tp + fp     A + C + A + B
+#
+# ref: [An extensive empirical study of feature selection metrics
+#       for text classification](http://dl.acm.org/citation.cfm?id=944974)
+#
+  class F1Measure < BaseDiscrete
+    
+    private
+    
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      each_class do |k|
+        a, b, c = get_A(f, k), get_B(f, k), get_C(f, k)
+      
+        s = 2*a / (a+c+a+b)
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  # shortcut so that you can use FSelector::F1 instead of FSelector::F1Measure
+  F1 = F1Measure
+  
+  
+end # module

data/lib/fselector/algo_discrete/FishersExactTest.rb

@@ -0,0 +1,47 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# (two-sided) Fisher's Exact Test (FET)
+# 
+#          (A+B)! * (C+D)! * (A+C)! * (B+D)!  
+#     p =  -----------------------------------
+#                  A! * B! * C! * D!
+#     
+#     for FET, the smaller, the better, but we intentionally negate it
+#     so that the larger is always the better (consistent with other algorithms)
+#
+# ref: [Wikipedia][wiki] and [Rubystats][url]
+# [wiki]: http://en.wikipedia.org/wiki/Fisher's_exact_test
+# [url]: http://rubystats.rubyforge.org
+#
+  class FishersExactTest < BaseDiscrete
+    # include Ruby statistics libraries
+    include Rubystats
+        
+    private
+        
+    # calculate contribution of each feature (f) for each class (k)
+    def calc_contribution(f)
+      @fet ||= Rubystats::FishersExactTest.new
+      
+      each_class do |k|
+        a, b, c, d = get_A(f, k), get_B(f, k), get_C(f, k), get_D(f, k)
+        
+        # note: we've intentionally negated it
+        s = -1 * @fet.calculate(a, b, c, d)[:twotail]
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::FET instead of FSelector::FishersExactTest
+  FET = FishersExactTest
+  
+  
+end # module

data/lib/fselector/algo_discrete/GMean.rb

@@ -0,0 +1,37 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# GMean (GM)
+#
+#     GM = sqrt(Sensitivity * Specificity)
+#     
+#                      TP*TN                     A*D
+#        = sqrt(------------------) = sqrt(---------------)
+#                (TP+FN) * (TN+FP)          (A+C) * (B+D)
+#
+  class GMean < 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 = Math.sqrt( (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::GM instead of FSelector::GMean
+  GM = GMean
+  
+  
+end # module

data/lib/fselector/algo_discrete/GSSCoefficient.rb

@@ -0,0 +1,43 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# GSS coefficient (GSS), a simplified variant of Chi-Squared
+# proposed by Galavotti
+#
+#     GSS(f,c) = P(f,c) * P(f',c') - P(f,c') * P(f',c)
+#     
+#              = A/N * D/N - B/N * C/N
+#
+# suitable for large samples and 
+# none of the values of (A, B, C, D) < 5
+#
+# ref: [A Comparative Study on Feature Selection Methods for Drug 
+#       Discovery](http://pubs.acs.org/doi/abs/10.1021/ci049875d)
+#
+  class GSSCoefficient < 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/n * d/n - b/n * c/n
+        
+        set_feature_score(f, k, s)
+      end
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::GSS instead of FSelector::GSSCoefficient
+  GSS = GSSCoefficient
+  
+  
+end # module

data/lib/fselector/algo_discrete/GiniIndex.rb

@@ -0,0 +1,44 @@
+#
+# FSelector: a Ruby gem for feature selection and ranking
+#
+module FSelector
+#
+# Gini Index (GI), generalized for multi-class problem
+#
+#     GI(f) = 1 - sigma(c)(P(c|f)^2)
+#
+# for GI, the smaller, the better, but we intentionally negate it
+# so that the larger is always the better (consistent with other algorithms)
+#
+# ref: [Advancing Feaure Selection Research -
+#       ASU Feature Selection Repository][url]
+# [url]: http://featureselection.asu.edu/featureselection_techreport.pdf
+#
+  class GiniIndex < BaseDiscrete
+          
+    private
+    
+    # calculate contribution of each feature (f) across all classes
+    def calc_contribution(f)
+      s = 0.0
+      
+      each_class do |k|
+        a, b = get_A(f, k), get_B(f, k)
+        s += (a/(a+b))**2
+      end
+      
+      # note: we've intentionally negated it
+      s = s-1
+      
+      set_feature_score(f, :BEST, s)
+    end # calc_contribution
+    
+    
+  end # class
+  
+  
+  # shortcut so that you can use FSelector::GI instead of FSelector::GiniIndex
+  GI = GiniIndex
+  
+  
+end # module