eps 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ca27ba2379d1cbfb6f3407ace5ad9dd5fcb71b08e48b8805ddda6483c026194
-  data.tar.gz: 91bb0beb50664dda5c2a42684414b1972e2bff91c3a993926639939c91272ccd
+  metadata.gz: a59850fe508d404a023145710505e721f1bfc24935a30a090aee09d179887d3a
+  data.tar.gz: 8218bc5bb63ee5ebbd23a8e9a129bcd76789b1f6bb628d57b015f1d5740183ac
 SHA512:
-  metadata.gz: 648d8098928d0ed952ad4cf2195b3e2562db5a38249357b76eb39c0aa17d8f8f974936c4773b2395ae1b1197aedb6e47c8fd018675496f3f966ee2feebb1ed2d
-  data.tar.gz: aa48887027114d9b654f3564715586a1740b742fe7778602d8db770b4921cff8acfbf90baea3ae6092d7c3962f37763c630857d71fbcd573402dfb016159f0c2
+  metadata.gz: db1011e9228763dc0a98e1e57d1c9e18a297d362cea18b33bf8eeffecce853ea49d4273ae4e782a6de2be37711e9e6373810e5517558248489e696b477c0848b
+  data.tar.gz: 6b9f52453be9d2ad7a29a4703508763988447de64a7599c53f9b9d3b0135e105130aba3c2679fed17ea60ba7242b6bd0d3cac9c5c2b796fe93f9009f0bbbcb30

data/CHANGELOG.md

@@ -1,4 +1,11 @@
-## 0.3.0
+## 0.3.1 (2019-12-06)
+
+- Added `weight` option for LightGBM and linear regression
+- Added `intercept` option for linear regression
+- Fixed `Unknown label` error for LightGBM
+- Fixed error message for unstable solutions with linear regression
+
+## 0.3.0 (2019-09-05)
 
 - Added support for LightGBM
 - Added text features
@@ -12,22 +19,22 @@ Breaking
 - Removed support for JSON and PFA formats
 - Added smoothing to naive Bayes
 
-## 0.2.1
+## 0.2.1 (2019-05-19)
 
 - Fixed error with `summary`
 - Fixed error with `predict` in `Eps::Base`
 - Fixed error with loaded classification models
 
-## 0.2.0
+## 0.2.0 (2019-05-19)
 
 - Added support for classification
 - Added `to_pmml` method
 - Added `Eps::Base`
 
-## 0.1.1
+## 0.1.1 (2018-07-05)
 
 - Huge performance boost
 
-## 0.1.0
+## 0.1.0 (2018-07-03)
 
 - First release

data/README.md

@@ -369,6 +369,12 @@ gem 'gsl', group: :development
 
 It only needs to be available in environments used to build the model.
 
+By default, an intercept is included. Disable this with:
+
+```ruby
+Eps::Model.new(data, intercept: false)
+```
+
 ## Validation Options
 
 Pass your own validation set with:
@@ -389,6 +395,12 @@ Specify the validation set size (the default is `0.25`, which is 25%)
 Eps::Model.new(data, split: {validation_size: 0.2})
 ```
 
+Disable the validation set completely with:
+
+```ruby
+Eps::Model.new(data, split: false)
+```
+
 ## Database Storage
 
 The database is another place you can store models. It’s good if you retrain models automatically.
@@ -419,6 +431,28 @@ model = Eps::Model.load_pmml(data)
 
 You can use [IRuby](https://github.com/SciRuby/iruby) to run Eps in [Jupyter](https://jupyter.org/) notebooks. Here’s how to get [IRuby working with Rails](https://ankane.org/jupyter-rails).
 
+## Weights
+
+Specify a weight for each data point
+
+```ruby
+Eps::Model.new(data, weight: :weight)
+```
+
+You can also pass an array
+
+```ruby
+Eps::Model.new(data, weight: [1, 2, 3])
+```
+
+Weights are supported for metrics as well
+
+```ruby
+Eps.metrics(actual, predicted, weight: weight)
+```
+
+Reweighing is one method to [mitigate bias](http://aif360.mybluemix.net/) in training data
+
 ## Upgrading
 
 ## 0.3.0

data/lib/eps.rb

@@ -1,5 +1,4 @@
 # dependencies
-require "bigdecimal"
 require "json"
 require "lightgbm"
 require "matrix"
@@ -9,10 +8,6 @@ require "nokogiri"
 require "eps/base"
 require "eps/base_estimator"
 require "eps/data_frame"
-require "eps/evaluators/linear_regression"
-require "eps/evaluators/lightgbm"
-require "eps/evaluators/naive_bayes"
-require "eps/evaluators/node"
 require "eps/label_encoder"
 require "eps/lightgbm"
 require "eps/linear_regression"
@@ -24,17 +19,31 @@ require "eps/text_encoder"
 require "eps/utils"
 require "eps/version"
 
+# pmml
+require "eps/pmml"
+require "eps/pmml/generator"
+require "eps/pmml/loader"
+
+# evaluators
+require "eps/evaluators/linear_regression"
+require "eps/evaluators/lightgbm"
+require "eps/evaluators/naive_bayes"
+require "eps/evaluators/node"
+
 module Eps
-  def self.metrics(y_true, y_pred)
+  class Error < StandardError; end
+  class UnstableSolution < Error; end
+
+  def self.metrics(y_true, y_pred, weight: nil)
     if Utils.column_type(y_true, "actual") == "numeric"
       {
-        rmse: Metrics.rmse(y_true, y_pred),
-        mae: Metrics.mae(y_true, y_pred),
-        me: Metrics.me(y_true, y_pred)
+        rmse: Metrics.rmse(y_true, y_pred, weight: weight),
+        mae: Metrics.mae(y_true, y_pred, weight: weight),
+        me: Metrics.me(y_true, y_pred, weight: weight)
       }
     else
       {
-        accuracy: Metrics.accuracy(y_true, y_pred)
+        accuracy: Metrics.accuracy(y_true, y_pred, weight: weight)
       }
     end
   end

data/lib/eps/base_estimator.rb

@@ -1,6 +1,9 @@
 module Eps
   class BaseEstimator
     def initialize(data = nil, y = nil, **options)
+      @options = options.dup
+      # TODO better pattern - don't pass most options to train
+      options.delete(:intercept)
       train(data, y, **options) if data
     end
 
@@ -28,22 +31,19 @@ module Eps
       singular ? predictions.first : predictions
     end
 
-    def evaluate(data, y = nil, target: nil)
-      data, target = prep_data(data, y, target || @target)
-      Eps.metrics(data.label, predict(data))
+    def evaluate(data, y = nil, target: nil, weight: nil)
+      data, target = prep_data(data, y, target || @target, weight)
+      Eps.metrics(data.label, predict(data), weight: data.weight)
     end
 
     def to_pmml
-      (@pmml ||= generate_pmml).to_xml
+      @pmml ||= PMML.generate(self)
     end
 
-    def self.load_pmml(data)
-      if data.is_a?(String)
-        data = Nokogiri::XML(data) { |config| config.strict }
-      end
+    def self.load_pmml(pmml)
       model = new
-      model.instance_variable_set("@pmml", data) # cache data
-      model.instance_variable_set("@evaluator", yield(data))
+      model.instance_variable_set("@evaluator", PMML.load(pmml))
+      model.instance_variable_set("@pmml", pmml.respond_to?(:to_xml) ? pmml.to_xml : pmml) # cache data
       model
     end
 
@@ -57,11 +57,11 @@ module Eps
         case @target_type
         when "numeric"
           metric_name = "RMSE"
-          v = Metrics.rmse(y_true, y_pred)
+          v = Metrics.rmse(y_true, y_pred, weight: @validation_set.weight)
           metric_value = v.round >= 1000 ? v.round.to_s : "%.3g" % v
         else
           metric_name = "accuracy"
-          metric_value = "%.1f%%" % (100 * Metrics.accuracy(y_true, y_pred)).round(1)
+          metric_value = "%.1f%%" % (100 * Metrics.accuracy(y_true, y_pred, weight: @validation_set.weight)).round(1)
         end
         str << "Validation %s: %s\n\n"  % [metric_name, metric_value]
       end
@@ -70,50 +70,10 @@ module Eps
       str
     end
 
-    # private
-    def self.extract_text_features(data, features)
-      # updates features object
-      vocabulary = {}
-      function_mapping = {}
-      derived_fields = {}
-      data.css("LocalTransformations DerivedField, TransformationDictionary DerivedField").each do |n|
-        name = n.attribute("name")&.value
-        field = n.css("FieldRef").attribute("field").value
-        value = n.css("Constant").text
-
-        field = field[10..-2] if field =~ /\Alowercase\(.+\)\z/
-        next if value.empty?
-
-        (vocabulary[field] ||= []) << value
-
-        function_mapping[field] = n.css("Apply").attribute("function").value
-
-        derived_fields[name] = [field, value]
-      end
-
-      functions = {}
-      data.css("TransformationDictionary DefineFunction").each do |n|
-        name = n.attribute("name").value
-        text_index = n.css("TextIndex")
-        functions[name] = {
-          tokenizer: Regexp.new(text_index.attribute("wordSeparatorCharacterRE").value),
-          case_sensitive: text_index.attribute("isCaseSensitive")&.value == "true"
-        }
-      end
-
-      text_features = {}
-      function_mapping.each do |field, function|
-        text_features[field] = functions[function].merge(vocabulary: vocabulary[field])
-        features[field] = "text"
-      end
-
-      [text_features, derived_fields]
-    end
-
     private
 
-    def train(data, y = nil, target: nil, split: nil, validation_set: nil, verbose: nil, text_features: nil, early_stopping: nil)
-      data, @target = prep_data(data, y, target)
+    def train(data, y = nil, target: nil, weight: nil, split: nil, validation_set: nil, verbose: nil, text_features: nil, early_stopping: nil)
+      data, @target = prep_data(data, y, target, weight)
       @target_type = Utils.column_type(data.label, @target)
 
       if split.nil?
@@ -121,6 +81,7 @@ module Eps
       end
 
       # cross validation
+      # TODO adjust based on weight
       if split && !validation_set
         split = {} if split == true
         split = {column: split} unless split.is_a?(Hash)
@@ -193,8 +154,9 @@ module Eps
       else
         @train_set = data.dup
         if validation_set
-          validation_set = Eps::DataFrame.new(validation_set)
-          validation_set.label = validation_set.columns.delete(@target)
+          raise "Target required for validation set" unless target
+          raise "Weight required for validation set" if data.weight && !weight
+          validation_set, _ = prep_data(validation_set, nil, @target, weight)
         end
       end
 
@@ -210,12 +172,27 @@ module Eps
       nil
     end
 
-    def prep_data(data, y, target)
+    def prep_data(data, y, target, weight)
       data = Eps::DataFrame.new(data)
+
+      # target
       target = (target || "target").to_s
       y ||= data.columns.delete(target)
       check_missing(y, target)
       data.label = y.to_a
+
+      # weight
+      if weight
+        weight =
+          if weight.respond_to?(:to_a)
+            weight.to_a
+          else
+            data.columns.delete(weight.to_s)
+          end
+        check_missing(weight, "weight")
+        data.weight = weight.to_a
+      end
+
       check_data(data)
       [data, target]
     end
@@ -251,6 +228,7 @@ module Eps
     def check_data(data)
       raise "No data" if data.empty?
       raise "Number of data points differs from target" if data.size != data.label.size
+      raise "Number of data points differs from weight" if data.weight && data.size != data.weight.size
     end
 
     def check_missing(c, name)
@@ -275,77 +253,5 @@ module Eps
         k
       end
     end
-
-    # pmml
-
-    def build_pmml(data_fields)
-      Nokogiri::XML::Builder.new do |xml|
-        xml.PMML(version: "4.4", xmlns: "http://www.dmg.org/PMML-4_4", "xmlns:xsi" => "http://www.w3.org/2001/XMLSchema-instance") do
-          pmml_header(xml)
-          pmml_data_dictionary(xml, data_fields)
-          pmml_transformation_dictionary(xml)
-          yield xml
-        end
-      end
-    end
-
-    def pmml_header(xml)
-      xml.Header do
-        xml.Application(name: "Eps", version: Eps::VERSION)
-        # xml.Timestamp Time.now.utc.iso8601
-      end
-    end
-
-    def pmml_data_dictionary(xml, data_fields)
-      xml.DataDictionary do
-        data_fields.each do |k, vs|
-          case @features[k]
-          when "categorical", nil
-            xml.DataField(name: k, optype: "categorical", dataType: "string") do
-              vs.map(&:to_s).sort.each do |v|
-                xml.Value(value: v)
-              end
-            end
-          when "text"
-            xml.DataField(name: k, optype: "categorical", dataType: "string")
-          else
-            xml.DataField(name: k, optype: "continuous", dataType: "double")
-          end
-        end
-      end
-    end
-
-    def pmml_transformation_dictionary(xml)
-      if @text_features.any?
-        xml.TransformationDictionary do
-          @text_features.each do |k, text_options|
-            xml.DefineFunction(name: "#{k}Transform", optype: "continuous") do
-              xml.ParameterField(name: "text")
-              xml.ParameterField(name: "term")
-              xml.TextIndex(textField: "text", localTermWeights: "termFrequency", wordSeparatorCharacterRE: text_options[:tokenizer].source, isCaseSensitive: !!text_options[:case_sensitive]) do
-                xml.FieldRef(field: "term")
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def pmml_local_transformations(xml)
-      if @text_features.any?
-        xml.LocalTransformations do
-          @text_features.each do |k, _|
-            @text_encoders[k].vocabulary.each do |v|
-              xml.DerivedField(name: display_field([k, v]), optype: "continuous", dataType: "integer") do
-                xml.Apply(function: "#{k}Transform") do
-                  xml.FieldRef(field: k)
-                  xml.Constant v
-                end
-              end
-            end
-          end
-        end
-      end
-    end
   end
 end

data/lib/eps/data_frame.rb

@@ -1,7 +1,7 @@
 module Eps
   class DataFrame
     attr_reader :columns
-    attr_accessor :label
+    attr_accessor :label, :weight
 
     def initialize(data = [])
       @columns = {}
@@ -78,6 +78,10 @@ module Eps
           rows = Range.new(rows.begin, size - 1)
         elsif rows.end < 0
           rows = Range.new(rows.begin, size + rows.end, rows.exclude_end?)
+        else
+          finish = rows.end
+          finish -= 1 if rows.exclude_end?
+          rows = Range.new(rows.begin, size - 1) if finish >= size - 1
         end
       end
 
@@ -115,6 +119,7 @@ module Eps
         df.columns[c] = columns[c].values_at(*rows)
       end
       df.label = label.values_at(*rows) if label
+      df.weight = weight.values_at(*rows) if weight
 
       singular ? df.columns[cols[0]] : df
     end
@@ -129,6 +134,7 @@ module Eps
         df.columns[k] = v
       end
       df.label = label
+      df.weight = weight
       df
     end
 

data/lib/eps/evaluators/linear_regression.rb

@@ -10,7 +10,7 @@ module Eps
       end
 
       def predict(x)
-        intercept = @coefficients["_intercept"]
+        intercept = @coefficients["_intercept"] || 0.0
         scores = [intercept] * x.size
 
         @features.each do |k, type|

data/lib/eps/label_encoder.rb

@@ -24,9 +24,13 @@ module Eps
         if yi.nil?
           nil
         else
-          v = @labels[yi.to_s]
-          raise "Unknown label: #{yi}" unless v
-          v
+          # use an additional label for unseen values
+          # this is only used during training for the LightGBM eval_set
+          # LightGBM ignores them (only uses seen categories for predictions)
+          # https://github.com/microsoft/LightGBM/issues/1936
+          # the evaluator also ignores them (to be consistent with LightGBM)
+          # but doesn't use this code
+          @labels[yi.to_s] || @labels.size
         end
       end
     end