eps 0.1.1 → 0.2.0

data/Gemfile

@@ -1,11 +0,0 @@
-source "https://rubygems.org"
-
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in eps.gemspec
-gemspec
-
-# remove when 0.2.1 released
-gem "daru", github: "sciruby/daru"
-
-gem "gsl" if ENV["GSL"]

data/Rakefile

@@ -1,34 +0,0 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
-  t.warning = false
-end
-
-task default: :test
-
-task :benchmark do
-  require "benchmark"
-  require "eps"
-  require "gsl" if ENV["GSL"]
-
-  data = []
-  10000.times do
-    row = {}
-    30.times do |i|
-      row[:"x#{i}"] = rand(100)
-    end
-    row[:y] = rand(100)
-    data << row
-  end
-
-  puts "Starting benchmark..."
-
-  time = Benchmark.realtime do
-    Eps::Regressor.new(data, target: :y)
-  end
-  p time.round(1)
-end

data/eps.gemspec

@@ -1,30 +0,0 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "eps/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "eps"
-  spec.version       = Eps::VERSION
-  spec.authors       = ["Andrew Kane"]
-  spec.email         = ["andrew@chartkick.com"]
-
-  spec.summary       = "Linear regression for Ruby"
-  spec.homepage      = "https://github.com/ankane/eps"
-  spec.license       = "MIT"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "daru"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "nokogiri"
-  spec.add_development_dependency "rake"
-end

data/guides/Modeling.md

@@ -1,152 +0,0 @@
-# Modeling
-
-- [R JSON](#r-json)
-- [R PMML](#r-pmml)
-- [R PFA](#r-pfa)
-- [Python JSON](#python-json)
-- [Python PMML](#python-pmml)
-- [Python PFA](#python-pfa)
-
-## R JSON
-
-Install the [jsonlite](https://cran.r-project.org/package=jsonlite) package
-
-```r
-install.packages("jsonlite")
-```
-
-And run:
-
-```r
-library(jsonlite)
-
-model <- lm(dist ~ speed, cars)
-data <- toJSON(list(coefficients=as.list(coef(model))), auto_unbox=TRUE)
-write(data, file="model.json")
-```
-
-## R PMML
-
-Install the [pmml](https://cran.r-project.org/package=pmml) package
-
-```r
-install.packages("pmml")
-```
-
-And run:
-
-```r
-library(pmml)
-
-model <- lm(dist ~ speed,  cars)
-data <- toString(pmml(model))
-write(data, file="model.pmml")
-```
-
-## R PFA
-
-Install the [aurelius](https://cran.r-project.org/package=aurelius) package
-
-```r
-install.packages("aurelius")
-```
-
-And run:
-
-```r
-library(aurelius)
-
-model <- lm(dist ~ speed,  cars)
-write_pfa(pfa(model), file="model.pfa")
-```
-
-## Python JSON
-
-Run:
-
-```python
-from sklearn import linear_model
-import pandas as pd
-import json
-
-x = [1, 2, 3, 4, 5]
-y = [5 * xi + 3 for xi in x]
-
-df = pd.DataFrame({'x': x, 'y': y})
-features = ['x']
-
-model = linear_model.LinearRegression()
-model.fit(df[features], df['y'])
-
-coefficients = {'_intercept': model.intercept_}
-for i, c in enumerate(model.coef_):
-    coefficients[features[i]] = c
-
-
-data = json.dumps({'coefficients': coefficients})
-
-with open('model.json', 'w') as f:
-    f.write(data)
-```
-
-## Python PMML
-
-Install the [scikit2pmml](https://github.com/vaclavcadek/scikit2pmml) package
-
-```sh
-pip install scikit2pmml
-```
-
-And run:
-
-```python
-from sklearn import linear_model
-from scikit2pmml import scikit2pmml
-
-x = [1, 2, 3, 5, 6]
-y = [5 * xi + 3 for xi in x]
-
-model = linear_model.LinearRegression()
-model.fit([[xi] for xi in x], y)
-
-scikit2pmml(estimator=model, file='model.pmml')
-```
-
-## Python PFA
-
-Install the [Titus](https://github.com/opendatagroup/hadrian) package and run:
-
-```python
-from sklearn import linear_model
-import titus.prettypfa
-import json
-
-x = [1, 2, 3, 5, 6]
-y = [5 * xi + 3 for xi in x]
-
-model = linear_model.LinearRegression()
-model.fit([[xi] for xi in x], y)
-
-def pfa(estimator):
-    pfaDocument = titus.prettypfa.jsonNode('''
-types:
-  Regression = record(Regression,
-                      const: double,
-                      coeff: array(double))
-input: array(double)
-output: double
-cells:
-  regression(Regression) = {const: 0.0, coeff: []}
-action:
-  model.reg.linear(input, regression)
-''')
-
-    pfaDocument["cells"]["regression"]["init"] = {"const": estimator.intercept_, "coeff": list(estimator.coef_)}
-
-    return pfaDocument
-
-data = json.dumps(pfa(model))
-
-with open('model.pfa', 'w') as f:
-    f.write(data)
-```

data/lib/eps/base_regressor.rb

@@ -1,232 +0,0 @@
-module Eps
-  class BaseRegressor
-    attr_reader :coefficients
-
-    def initialize(coefficients:)
-      @coefficients = Hash[coefficients.map { |k, v| [k.to_sym, v] }]
-    end
-
-    def predict(x)
-      singular = !(x.is_a?(Array) || daru?(x))
-      x = [x] if singular
-      x, c = prep_x(x, train: false)
-      coef = c.map do |v|
-        # use 0 if coefficient does not exist
-        # this can happen for categorical features
-        # since only n-1 coefficients are stored
-        coefficients[v] || 0
-      end
-
-      x = Matrix.rows(x)
-      c = Matrix.column_vector(coef)
-      pred = matrix_arr(x * c)
-
-      singular ? pred[0] : pred
-    end
-
-    def evaluate(data, y = nil, target: nil)
-      raise ArgumentError, "missing target" if !target && !y
-
-      actual = y
-      actual ||=
-        if daru?(data)
-          data[target].to_a
-        else
-          data.map { |v| v[target] }
-        end
-
-      actual = prep_y(actual)
-      estimated = predict(data)
-      Eps.metrics(actual, estimated)
-    end
-
-    # ruby
-
-    def self.load(data)
-      BaseRegressor.new(Hash[data.map { |k, v| [k.to_sym, v] }])
-    end
-
-    def dump
-      {coefficients: coefficients}
-    end
-
-    # json
-
-    def self.load_json(data)
-      data = JSON.parse(data) if data.is_a?(String)
-      coefficients = data["coefficients"]
-
-      # for R models
-      if coefficients["(Intercept)"]
-        coefficients = coefficients.dup
-        coefficients["_intercept"] = coefficients.delete("(Intercept)")
-      end
-
-      BaseRegressor.new(coefficients: coefficients)
-    end
-
-    def to_json
-      JSON.generate(dump)
-    end
-
-    # pmml
-
-    def self.load_pmml(data)
-      if data.is_a?(String)
-        require "nokogiri"
-        data = Nokogiri::XML(data)
-      end
-
-      # TODO more validation
-      node = data.css("RegressionTable")
-      coefficients = {
-        _intercept: node.attribute("intercept").value.to_f
-      }
-      node.css("NumericPredictor").each do |n|
-        coefficients[n.attribute("name").value] = n.attribute("coefficient").value.to_f
-      end
-      node.css("CategoricalPredictor").each do |n|
-        coefficients["#{n.attribute("name").value}#{n.attribute("value").value}"] = n.attribute("coefficient").value.to_f
-      end
-      BaseRegressor.new(coefficients: coefficients)
-    end
-
-    # pfa
-
-    def self.load_pfa(data)
-      data = JSON.parse(data) if data.is_a?(String)
-      init = data["cells"].first[1]["init"]
-      names =
-        if data["input"]["fields"]
-          data["input"]["fields"].map { |f| f["name"] }
-        else
-          init["coeff"].map.with_index { |_, i| "x#{i}" }
-        end
-      coefficients = {
-        _intercept: init["const"]
-      }
-      init["coeff"].each_with_index do |c, i|
-        name = names[i]
-        # R can export coefficients with same name
-        raise "Coefficients with same name" if coefficients[name]
-        coefficients[name] = c
-      end
-      BaseRegressor.new(coefficients: coefficients)
-    end
-
-    protected
-
-    def daru?(x)
-      defined?(Daru) && x.is_a?(Daru::DataFrame)
-    end
-
-    def prep_x(x, train: true)
-      if daru?(x)
-        x = x.to_a[0]
-      else
-        x = x.map do |xi|
-          case xi
-          when Hash
-            xi
-          when Array
-            Hash[xi.map.with_index { |v, i| [:"x#{i}", v] }]
-          else
-            {x0: xi}
-          end
-        end
-      end
-
-      # if !train && x.any?
-      #   # check first row against coefficients
-      #   ckeys = coefficients.keys.map(&:to_s)
-      #   bad_keys = x[0].keys.map(&:to_s).reject { |k| ckeys.any? { |c| c.start_with?(k) } }
-      #   raise "Unknown keys: #{bad_keys.join(", ")}" if bad_keys.any?
-      # end
-
-      cache = {}
-      first_key = {}
-      i = 0
-      rows = []
-      x.each do |xi|
-        row = {}
-        xi.each do |k, v|
-          key = v.is_a?(String) ? [k.to_sym, v] : k.to_sym
-          v2 = v.is_a?(String) ? 1 : v
-
-          # TODO make more efficient
-          next if !train && !coefficients.key?(symbolize_coef(key))
-
-          raise "Missing data" if v2.nil?
-
-          unless cache[key]
-            cache[key] = i
-            first_key[k] ||= key if v.is_a?(String)
-            i += 1
-          end
-
-          row[key] = v2
-        end
-        rows << row
-      end
-
-      if train
-        # remove one degree of freedom
-        first_key.values.each do |v|
-          num = cache.delete(v)
-          cache.each do |k, v2|
-            cache[k] -= 1 if v2 > num
-          end
-        end
-      end
-
-      ret2 = []
-      rows.each do |row|
-        ret = [0] * cache.size
-        row.each do |k, v|
-          if cache[k]
-            ret[cache[k]] = v
-          end
-        end
-        ret2 << ([1] + ret)
-      end
-
-      # flatten keys
-      c = [:_intercept] + cache.sort_by { |_, v| v }.map { |k, _| symbolize_coef(k) }
-
-      if c.size != c.uniq.size
-        raise "Overlapping coefficients"
-      end
-
-      [ret2, c]
-    end
-
-    def symbolize_coef(k)
-      (k.is_a?(Array) ? k.join("") : k).to_sym
-    end
-
-    def matrix_arr(matrix)
-      matrix.to_a.map { |xi| xi[0].to_f }
-    end
-
-    # determine if target is a string or symbol
-    def prep_target(target, data)
-      if daru?(data)
-        data.has_vector?(target) ? target : flip_target(target)
-      else
-        x = data[0] || {}
-        x[target] ? target : flip_target(target)
-      end
-    end
-
-    def flip_target(target)
-      target.is_a?(String) ? target.to_sym : target.to_s
-    end
-
-    def prep_y(y)
-      y.each do |yi|
-        raise "Target missing in data" if yi.nil?
-      end
-      y.map(&:to_f)
-    end
-  end
-end