eps 0.2.1 → 0.3.0

data/lib/eps/pmml_generators/lightgbm.rb

@@ -0,0 +1,187 @@
+module Eps
+  module PmmlGenerators
+    module LightGBM
+      private
+
+      def generate_pmml
+        feature_importance = @feature_importance
+
+        data_fields = {}
+        data_fields[@target] = @labels if @labels
+        @features.each_with_index do |(k, type), i|
+          # TODO remove zero importance features
+          if type == "categorical"
+            data_fields[k] = @label_encoders[k].labels.keys
+          else
+            data_fields[k] = nil
+          end
+        end
+
+        build_pmml(data_fields) do |xml|
+          function_name = @objective == "regression" ? "regression" : "classification"
+          xml.MiningModel(functionName: function_name, algorithmName: "LightGBM") do
+            xml.MiningSchema do
+              xml.MiningField(name: @target, usageType: "target")
+              @features.keys.each_with_index do |k, i|
+                # next if feature_importance[i] == 0
+                # TODO add importance, but need to handle text features
+                xml.MiningField(name: k) #, importance: feature_importance[i].to_f, missingValueTreatment: "asIs")
+              end
+            end
+            pmml_local_transformations(xml)
+
+            case @objective
+            when "regression"
+              xml_segmentation(xml, @trees)
+            when "binary"
+              xml.Segmentation(multipleModelMethod: "modelChain") do
+                xml.Segment(id: 1) do
+                  xml.True
+                  xml.MiningModel(functionName: "regression") do
+                    xml.MiningSchema do
+                      @features.each do |k, _|
+                        xml.MiningField(name: k)
+                      end
+                    end
+                    xml.Output do
+                      xml.OutputField(name: "lgbmValue", optype: "continuous", dataType: "double", feature: "predictedValue", isFinalResult: false) do
+                        xml.Apply(function: "/") do
+                          xml.Constant(dataType: "double") do
+                            1.0
+                          end
+                          xml.Apply(function: "+") do
+                            xml.Constant(dataType: "double") do
+                              1.0
+                            end
+                            xml.Apply(function: "exp") do
+                              xml.Apply(function: "*") do
+                                xml.Constant(dataType: "double") do
+                                  -1.0
+                                end
+                                xml.FieldRef(field: "lgbmValue")
+                              end
+                            end
+                          end
+                        end
+                      end
+                    end
+                    xml_segmentation(xml, @trees)
+                  end
+                end
+                xml.Segment(id: 2) do
+                  xml.True
+                  xml.RegressionModel(functionName: "classification", normalizationMethod: "none") do
+                    xml.MiningSchema do
+                      xml.MiningField(name: @target, usageType: "target")
+                      xml.MiningField(name: "transformedLgbmValue")
+                    end
+                    xml.Output do
+                      @labels.each do |label|
+                        xml.OutputField(name: "probability(#{label})", optype: "continuous", dataType: "double", feature: "probability", value: label)
+                      end
+                    end
+                    xml.RegressionTable(intercept: 0.0, targetCategory: @labels.last) do
+                      xml.NumericPredictor(name: "transformedLgbmValue", coefficient: "1.0")
+                    end
+                    xml.RegressionTable(intercept: 0.0, targetCategory: @labels.first)
+                  end
+                end
+              end
+            else # multiclass
+              xml.Segmentation(multipleModelMethod: "modelChain") do
+                n = @trees.size / @labels.size
+                @trees.each_slice(n).each_with_index do |trees, idx|
+                  xml.Segment(id: idx + 1) do
+                    xml.True
+                    xml.MiningModel(functionName: "regression") do
+                      xml.MiningSchema do
+                        @features.each do |k, _|
+                          xml.MiningField(name: k)
+                        end
+                      end
+                      xml.Output do
+                        xml.OutputField(name: "lgbmValue(#{@labels[idx]})", optype: "continuous", dataType: "double", feature: "predictedValue", isFinalResult: false)
+                      end
+                      xml_segmentation(xml, trees)
+                    end
+                  end
+                end
+                xml.Segment(id: @labels.size + 1) do
+                  xml.True
+                  xml.RegressionModel(functionName: "classification", normalizationMethod: "softmax") do
+                    xml.MiningSchema do
+                      xml.MiningField(name: @target, usageType: "target")
+                      @labels.each do |label|
+                        xml.MiningField(name: "lgbmValue(#{label})")
+                      end
+                    end
+                    xml.Output do
+                      @labels.each do |label|
+                        xml.OutputField(name: "probability(#{label})", optype: "continuous", dataType: "double", feature: "probability", value: label)
+                      end
+                    end
+                    @labels.each do |label|
+                      xml.RegressionTable(intercept: 0.0, targetCategory: label) do
+                        xml.NumericPredictor(name: "lgbmValue(#{label})", coefficient: "1.0")
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def xml_segmentation(xml, trees)
+        xml.Segmentation(multipleModelMethod: "sum") do
+          trees.each_with_index do |node, i|
+            xml.Segment(id: i + 1) do
+              xml.True
+              xml.TreeModel(functionName: "regression", missingValueStrategy: "none", noTrueChildStrategy: "returnLastPrediction", splitCharacteristic: "multiSplit") do
+                xml.MiningSchema do
+                  node_fields(node).uniq.each do |k|
+                    xml.MiningField(name: display_field(k))
+                  end
+                end
+                node_pmml(node, xml)
+              end
+            end
+          end
+        end
+      end
+
+      def node_fields(node)
+        fields = []
+        fields << node.field if node.predicate
+        node.children.each do |n|
+          fields.concat(node_fields(n))
+        end
+        fields
+      end
+
+      def node_pmml(node, xml)
+        xml.Node(score: node.score) do
+          if node.predicate.nil?
+            xml.True
+          elsif node.operator == "in"
+            xml.SimpleSetPredicate(field: display_field(node.field), booleanOperator: "isIn") do
+              xml.Array(type: "string") do
+                xml.text node.value.map { |v| escape_element(v) }.join(" ")
+              end
+            end
+          else
+            xml.SimplePredicate(field: display_field(node.field), operator: node.operator, value: node.value)
+          end
+          node.children.each do |n|
+            node_pmml(n, xml)
+          end
+        end
+      end
+
+      def escape_element(v)
+        "\"#{v.gsub("\"", "\\\"")}\""
+      end
+    end
+  end
+end

data/lib/eps/statistics.rb

@@ -0,0 +1,79 @@
+### Extracted from https://github.com/estebanz01/ruby-statistics
+### The Ruby author is Esteban Zapata Rojas
+###
+### Originally extracted from https://codeplea.com/incomplete-beta-function-c
+### These functions shared under zlib license and the author is Lewis Van Winkle
+
+module Eps
+  module Statistics
+    def self.tdist_p(value, degrees_of_freedom)
+      upper = (value + Math.sqrt(value * value + degrees_of_freedom))
+      lower = (2.0 * Math.sqrt(value * value + degrees_of_freedom))
+
+      x = upper/lower
+
+      alpha = degrees_of_freedom/2.0
+      beta = degrees_of_freedom/2.0
+
+      incomplete_beta_function(x, alpha, beta)
+    end
+
+    def self.incomplete_beta_function(x, alp, bet)
+      return if x < 0.0
+      return 1.0 if x > 1.0
+
+      tiny = 1.0E-50
+
+      if x > ((alp + 1.0)/(alp + bet + 2.0))
+        return 1.0 - incomplete_beta_function(1.0 - x, bet, alp)
+      end
+
+      # To avoid overflow problems, the implementation applies the logarithm properties
+      # to calculate in a faster and safer way the values.
+      lbet_ab = (Math.lgamma(alp)[0] + Math.lgamma(bet)[0] - Math.lgamma(alp + bet)[0]).freeze
+      front = (Math.exp(Math.log(x) * alp + Math.log(1.0 - x) * bet - lbet_ab) / alp.to_f).freeze
+
+      # This is the non-log version of the left part of the formula (before the continuous fraction)
+      # down_left = alp * self.beta_function(alp, bet)
+      # upper_left = (x ** alp) * ((1.0 - x) ** bet)
+      # front = upper_left/down_left
+
+      f, c, d = 1.0, 1.0, 0.0
+
+      returned_value = nil
+
+      # Let's do more iterations than the proposed implementation (200 iters)
+      (0..500).each do |number|
+        m = number/2
+
+        numerator = if number == 0
+                      1.0
+                    elsif number % 2 == 0
+                      (m * (bet - m) * x)/((alp + 2.0 * m - 1.0)* (alp + 2.0 * m))
+                    else
+                      top = -((alp + m) * (alp + bet + m) * x)
+                      down = ((alp + 2.0 * m) * (alp + 2.0 * m + 1.0))
+
+                      top/down
+                    end
+
+        d = 1.0 + numerator * d
+        d = tiny if d.abs < tiny
+        d = 1.0 / d
+
+        c = 1.0 + numerator / c
+        c = tiny if c.abs < tiny
+
+        cd = (c*d).freeze
+        f = f * cd
+
+        if (1.0 - cd).abs < 1.0E-10
+          returned_value = front * (f - 1.0)
+          break
+        end
+      end
+
+      returned_value
+    end
+  end
+end

data/lib/eps/text_encoder.rb

@@ -0,0 +1,81 @@
+module Eps
+  class TextEncoder
+    attr_reader :options, :vocabulary
+
+    def initialize(**options)
+      @options = options
+      @vocabulary = options[:vocabulary] || []
+    end
+
+    def fit(arr)
+      counts, fit = count_and_fit(arr)
+
+      min_length = options[:min_length]
+      if min_length
+        counts.select! { |k, _| k.length >= min_length }
+      end
+
+      min_occurrences = options[:min_occurrences]
+      if min_occurrences
+        counts.select! { |_, v| v >= min_occurrences }
+      end
+
+      max_occurrences = options[:max_occurrences]
+      if max_occurrences
+        counts.reject! { |_, v| v > max_occurrences }
+      end
+
+      max_features = options[:max_features]
+      if max_features
+        counts = Hash[counts.sort_by { |_, v| -v }[0...max_features]]
+      end
+
+      @vocabulary = counts.keys
+
+      fit
+    end
+
+    def transform(arr)
+      counts, fit = count_and_fit(arr)
+      fit
+    end
+
+    private
+
+    def count_and_fit(arr)
+      tokenizer = options[:tokenizer]
+      stop_words = Array(options[:stop_words])
+
+      fit =
+        arr.map do |xi|
+          # tokenize
+          tokens = xi.to_s
+          tokens = tokens.downcase unless options[:case_sensitive]
+          tokens = tokens.split(tokenizer)
+
+          # remove stop words
+          tokens -= stop_words
+
+          # count
+          xc = Hash.new(0)
+          tokens.each do |token|
+            xc[token] += 1
+          end
+          xc
+        end
+
+      counts = Hash.new(0)
+
+      fit.each do |xc|
+        xc.each do |k2, v2|
+          counts[k2] += v2
+        end
+      end
+
+      # remove empty strings
+      counts.delete("")
+
+      [counts, fit]
+    end
+  end
+end

data/lib/eps/utils.rb

@@ -0,0 +1,22 @@
+module Eps
+  module Utils
+    def self.column_type(c, k)
+      if !c
+        raise ArgumentError, "Missing column: #{k}"
+      elsif c.all? { |v| v.nil? }
+        # goes here for empty as well
+        nil
+      elsif c.any? { |v| v.nil? }
+        raise ArgumentError, "Missing values in column #{k}"
+      elsif c.all? { |v| v.is_a?(Numeric) }
+        "numeric"
+      elsif c.all? { |v| v.is_a?(String) }
+        "categorical"
+      elsif c.all? { |v| v == true || v == false }
+        "categorical" # boolean
+      else
+        raise ArgumentError, "Column values must be all numeric, all string, or all boolean: #{k}"
+      end
+    end
+  end
+end

data/lib/eps/version.rb

@@ -1,3 +1,3 @@
 module Eps
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,23 +1,37 @@
 --- !ruby/object:Gem::Specification
 name: eps
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-19 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: lightgbm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.5
+- !ruby/object:Gem::Dependency
+  name: nokogiri
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -25,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: daru
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: daru
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: nokogiri
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -92,9 +106,21 @@ files:
 - lib/eps.rb
 - lib/eps/base.rb
 - lib/eps/base_estimator.rb
+- lib/eps/data_frame.rb
+- lib/eps/evaluators/lightgbm.rb
+- lib/eps/evaluators/linear_regression.rb
+- lib/eps/evaluators/naive_bayes.rb
+- lib/eps/evaluators/node.rb
+- lib/eps/label_encoder.rb
+- lib/eps/lightgbm.rb
 - lib/eps/linear_regression.rb
+- lib/eps/metrics.rb
 - lib/eps/model.rb
 - lib/eps/naive_bayes.rb
+- lib/eps/pmml_generators/lightgbm.rb
+- lib/eps/statistics.rb
+- lib/eps/text_encoder.rb
+- lib/eps/utils.rb
 - lib/eps/version.rb
 homepage: https://github.com/ankane/eps
 licenses: