xgb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dcb0666c9eb0943a77ccdbaa31074b8ca0b139ac196006b5cd6d680f6f91ac30
-  data.tar.gz: 673040af645aafc5f14378121b9dac594b5dc6dae0449f75244cc9cfeaaa10e3
+  metadata.gz: 1bb50395d579da91b18754bc75e780cbb2e98fd7a48a17c34514230d1c4828d1
+  data.tar.gz: 3d2f9c5a72c63c2622a973805c9f2caa9bd4de7b5c67f8c4b5445fd9a71993c3
 SHA512:
-  metadata.gz: 3f2838ee9f2b69ea69fdc9f3610a36f412acb8732f726478995dad0ebcf73325f99c6c3afc480ae60458035619c83f9e2c9a03d60020cf8e734ea250334541c0
-  data.tar.gz: 69034ec7cad4174837cc8347ab5cc13144532701927aa702eb93c6819ddf8ffe6d3c5c3752b39de863178e7d404cef017ddd82b7fe811aa4d5f3b62aa051729d
+  metadata.gz: f141b3ea0b6ceb8549198fd6ad8a07f6947201409478fc4829fe625da376e40d8028427a5aa34191b565aa275d27bb03e2082bb8fc489f6da6a2a09b3bbf2c2f
+  data.tar.gz: c393f4fdbe240ffc14b64f22f17d149ed393070fb0752f9ec49dd94bcfa88f446ea21bc5bf9a96bef7759c5c47033dd0480a4001d477b8c487cf5dcf8be19b81

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.1.1
+
+- Added Scikit-Learn API
+- Added early stopping
+- Added `cv` method
+- Added support for Daru and Numo::NArray
+- Added many other methods
+- Fixed shape of multiclass predictions when loaded from file
+
 ## 0.1.0
 
 - First release

data/README.md

@@ -4,6 +4,8 @@
 
 :fire: Uses the C API for blazing performance
 
+[![Build Status](https://travis-ci.org/ankane/xgb.svg?branch=master)](https://travis-ci.org/ankane/xgb)
+
 ## Installation
 
 First, [install XGBoost](https://xgboost.readthedocs.io/en/latest/build.html). On Mac, copy `lib/libxgboost.dylib` to `/usr/local/lib`.
@@ -16,12 +18,16 @@ gem 'xgb'
 
 ## Getting Started
 
+This library follows the [Core Data Structure, Learning and Scikit-Learn APIs](https://xgboost.readthedocs.io/en/latest/python/python_api.html) of the Python library. Some methods and options are missing at the moment. PRs welcome!
+
+## Learning API
+
 Train a model
 
 ```ruby
 params = {objective: "reg:squarederror"}
-train_set = Xgb::DMatrix.new(x_train, label: y_train)
-booster = Xgb.train(params, train_set)
+dtrain = Xgb::DMatrix.new(x_train, label: y_train)
+booster = Xgb.train(params, dtrain)
 ```
 
 Predict
@@ -33,18 +39,96 @@ booster.predict(x_test)
 Save the model to a file
 
 ```ruby
-booster.save_model("model.txt")
+booster.save_model("my.model")
 ```
 
 Load the model from a file
 
 ```ruby
-booster = Xgb::Booster.new(model_file: "model.txt")
+booster = Xgb::Booster.new(model_file: "my.model")
+```
+
+Get the importance of features
+
+```ruby
+booster.score
+```
+
+Early stopping
+
+```ruby
+Xgb.train(params, dtrain, evals: [[dtrain, "train"], [dtest, "eval"]], early_stopping_rounds: 5)
+```
+
+CV
+
+```ruby
+Xgb.cv(params, dtrain, nfold: 3, verbose_eval: true)
 ```
 
-## Reference
+## Scikit-Learn API
 
-This library follows the [Core Data Structure and Learning APIs](https://xgboost.readthedocs.io/en/latest/python/python_api.html) for the Python library. Some methods and options are missing at the moment. PRs welcome!
+Prep your data
+
+```ruby
+x = [[1, 2], [3, 4], [5, 6], [7, 8]]
+y = [1, 2, 3, 4]
+```
+
+Train a model
+
+```ruby
+model = Xgb::Regressor.new
+model.fit(x, y)
+```
+
+> For classification, use `Xgb::Classifier`
+
+Predict
+
+```ruby
+model.predict(x)
+```
+
+> For classification, use `predict_proba` for probabilities
+
+Save the model to a file
+
+```ruby
+model.save_model("my.model")
+```
+
+Load the model from a file
+
+```ruby
+model.load_model("my.model")
+```
+
+Get the importance of features
+
+```ruby
+model.feature_importances
+```
+
+## Data
+
+Data can be an array of arrays
+
+```ruby
+[[1, 2, 3], [4, 5, 6]]
+```
+
+Or a Daru data frame
+
+```ruby
+Daru::DataFrame.from_csv("houses.csv")
+```
+
+Or a Numo NArray
+
+```ruby
+Numo::DFloat.new(3, 2).seq
+```
 
 ## Helpful Resources
 

data/lib/xgb.rb

@@ -8,19 +8,157 @@ require "xgb/dmatrix"
 require "xgb/ffi"
 require "xgb/version"
 
+# scikit-learn API
+require "xgb/classifier"
+require "xgb/regressor"
+
 module Xgb
   class Error < StandardError; end
 
   class << self
-    def train(params, dtrain, num_boost_round: 10)
+    def train(params, dtrain, num_boost_round: 10, evals: nil, early_stopping_rounds: nil, verbose_eval: true)
       booster = Booster.new(params: params)
-      booster.set_param("num_feature", dtrain.num_col)
+      num_feature = dtrain.num_col
+      booster.set_param("num_feature", num_feature)
+      booster.feature_names = num_feature.times.map { |i| "f#{i}" }
+      evals ||= []
+
+      if early_stopping_rounds
+        best_score = nil
+        best_iter = nil
+        best_message = nil
+      end
 
       num_boost_round.times do |iteration|
         booster.update(dtrain, iteration)
+
+        if evals.any?
+          message = booster.eval_set(evals, iteration)
+          res = message.split.map { |x| x.split(":") }[1..-1].map { |k, v| [k, v.to_f] }
+
+          if early_stopping_rounds && iteration == 0
+            metric = res[-1][0]
+            puts "Will train until #{metric} hasn't improved in #{early_stopping_rounds.to_i} rounds." if verbose_eval
+          end
+
+          puts message if verbose_eval
+          score = res[-1][1]
+
+          # TODO handle larger better
+          if best_score.nil? || score < best_score
+            best_score = score
+            best_iter = iteration
+            best_message = message
+          elsif iteration - best_iter >= early_stopping_rounds
+            booster.best_iteration = best_iter
+            puts "Stopping. Best iteration:\n#{best_message}" if verbose_eval
+            break
+          end
+        end
       end
 
       booster
     end
+
+    def cv(params, dtrain, num_boost_round: 10, nfold: 3, seed: 0, shuffle: true, verbose_eval: nil, show_stdv: true, early_stopping_rounds: nil)
+      rand_idx = (0...dtrain.num_row).to_a
+      rand_idx.shuffle!(random: Random.new(seed)) if shuffle
+
+      kstep = (rand_idx.size / nfold.to_f).ceil
+      test_id = rand_idx.each_slice(kstep).to_a[0...nfold]
+      train_id = []
+      nfold.times do |i|
+        idx = test_id.dup
+        idx.delete_at(i)
+        train_id << idx.flatten
+      end
+
+      folds = train_id.zip(test_id)
+      cvfolds = []
+      folds.each do |(train_idx, test_idx)|
+        fold_dtrain = dtrain.slice(train_idx)
+        fold_dvalid = dtrain.slice(test_idx)
+        booster = Booster.new(params: params)
+        booster.set_param("num_feature", dtrain.num_col)
+        cvfolds << [booster, fold_dtrain, fold_dvalid]
+      end
+
+      eval_hist = {}
+
+      if early_stopping_rounds
+        best_score = nil
+        best_iter = nil
+      end
+
+      num_boost_round.times do |iteration|
+        scores = {}
+
+        cvfolds.each do |(booster, fold_dtrain, fold_dvalid)|
+          booster.update(fold_dtrain, iteration)
+          message = booster.eval_set([[fold_dtrain, "train"], [fold_dvalid, "test"]], iteration)
+
+          res = message.split.map { |x| x.split(":") }[1..-1].map { |k, v| [k, v.to_f] }
+          res.each do |k, v|
+            (scores[k] ||= []) << v
+          end
+        end
+
+        message_parts = ["[#{iteration}]"]
+
+        last_mean = nil
+        means = {}
+        scores.each do |eval_name, vals|
+          mean = mean(vals)
+          stdev = stdev(vals)
+
+          (eval_hist["#{eval_name}-mean"] ||= []) << mean
+          (eval_hist["#{eval_name}-std"] ||= []) << stdev
+
+          means[eval_name] = mean
+          last_mean = mean
+
+          if show_stdv
+            message_parts << "%s:%g+%g" % [eval_name, mean, stdev]
+          else
+            message_parts << "%s:%g" % [eval_name, mean]
+          end
+        end
+
+        if early_stopping_rounds
+          score = last_mean
+          # TODO handle larger better
+          if best_score.nil? || score < best_score
+            best_score = score
+            best_iter = iteration
+          elsif iteration - best_iter >= early_stopping_rounds
+            eval_hist.each_key do |k|
+              eval_hist[k] = eval_hist[k][0..best_iter]
+            end
+            break
+          end
+        end
+
+        # put at end to keep output consistent with Python
+        puts message_parts.join("\t") if verbose_eval
+      end
+
+      eval_hist
+    end
+
+    private
+
+    def mean(arr)
+      arr.sum / arr.size.to_f
+    end
+
+    # don't subtract one from arr.size
+    def stdev(arr)
+      m = mean(arr)
+      sum = 0
+      arr.each do |v|
+        sum += (v - m) ** 2
+      end
+      Math.sqrt(sum / arr.size)
+    end
   end
 end

data/lib/xgb/booster.rb

@@ -1,5 +1,7 @@
 module Xgb
   class Booster
+    attr_accessor :best_iteration, :feature_names
+
     def initialize(params: nil, model_file: nil)
       @handle = ::FFI::MemoryPointer.new(:pointer)
       check_result FFI.XGBoosterCreate(nil, 0, @handle)
@@ -7,14 +9,28 @@ module Xgb
         check_result FFI.XGBoosterLoadModel(handle_pointer, model_file)
       end
 
+      self.best_iteration = 0
       set_param(params)
-      @num_class = (params && params[:num_class]) || 1
     end
 
     def update(dtrain, iteration)
       check_result FFI.XGBoosterUpdateOneIter(handle_pointer, iteration, dtrain.handle_pointer)
     end
 
+    def eval_set(evals, iteration)
+      dmats = ::FFI::MemoryPointer.new(:pointer, evals.size)
+      dmats.write_array_of_pointer(evals.map { |v| v[0].handle_pointer })
+
+      evnames = ::FFI::MemoryPointer.new(:pointer, evals.size)
+      evnames.write_array_of_pointer(evals.map { |v| ::FFI::MemoryPointer.from_string(v[1]) })
+
+      out_result = ::FFI::MemoryPointer.new(:pointer)
+
+      check_result FFI.XGBoosterEvalOneIter(handle_pointer, iteration, dmats, evnames, evals.size, out_result)
+
+      out_result.read_pointer.read_string
+    end
+
     def set_param(params, value = nil)
       if params.is_a?(Enumerable)
         params.each do |k, v|
@@ -27,11 +43,12 @@ module Xgb
 
     def predict(data, ntree_limit: nil)
       ntree_limit ||= 0
-      out_len = ::FFI::MemoryPointer.new(:long)
+      out_len = ::FFI::MemoryPointer.new(:ulong)
       out_result = ::FFI::MemoryPointer.new(:pointer)
       check_result FFI.XGBoosterPredict(handle_pointer, data.handle_pointer, 0, ntree_limit, out_len, out_result)
-      out = out_result.read_pointer.read_array_of_float(out_len.read_long)
-      out = out.each_slice(@num_class).to_a if @num_class > 1
+      out = out_result.read_pointer.read_array_of_float(out_len.read_ulong)
+      num_class = out.size / data.num_row
+      out = out.each_slice(num_class).to_a if num_class > 1
       out
     end
 
@@ -39,6 +56,97 @@ module Xgb
       check_result FFI.XGBoosterSaveModel(handle_pointer, fname)
     end
 
+    # returns an array of strings
+    def dump(fmap: "", with_stats: false, dump_format: "text")
+      out_len = ::FFI::MemoryPointer.new(:ulong)
+      out_result = ::FFI::MemoryPointer.new(:pointer)
+      check_result FFI.XGBoosterDumpModelEx(handle_pointer, fmap, with_stats ? 1 : 0, dump_format, out_len, out_result)
+      out_result.read_pointer.get_array_of_string(0, out_len.read_ulong)
+    end
+
+    def dump_model(fout, fmap: "", with_stats: false, dump_format: "text")
+      ret = dump(fmap: fmap, with_stats: with_stats, dump_format: dump_format)
+      File.open(fout, "wb") do |f|
+        if dump_format == "json"
+          f.print("[\n")
+          ret.each_with_index do |r, i|
+            f.print(r)
+            f.print(",\n") if i < ret.size - 1
+          end
+          f.print("\n]")
+        else
+          ret.each_with_index do |r, i|
+            f.print("booster[#{i}]:\n")
+            f.print(r)
+          end
+        end
+      end
+    end
+
+    def fscore(fmap: "")
+      # always weight
+      score(fmap: fmap, importance_type: "weight")
+    end
+
+    def score(fmap: "", importance_type: "weight")
+      if importance_type == "weight"
+        trees = dump(fmap: fmap, with_stats: false)
+        fmap = {}
+        trees.each do |tree|
+          tree.split("\n").each do |line|
+            arr = line.split("[")
+            next if arr.size == 1
+
+            fid = arr[1].split("]")[0].split("<")[0]
+            fmap[fid] ||= 0
+            fmap[fid] += 1
+          end
+        end
+        fmap
+      else
+        average_over_splits = true
+        if importance_type == "total_gain"
+          importance_type = "gain"
+          average_over_splits = false
+        elsif importance_type == "total_cover"
+          importance_type = "cover"
+          average_over_splits = false
+        end
+
+        trees = dump(fmap: fmap, with_stats: true)
+
+        importance_type += "="
+        fmap = {}
+        gmap = {}
+        trees.each do |tree|
+          tree.split("\n").each do |line|
+            arr = line.split("[")
+            next if arr.size == 1
+
+            fid = arr[1].split("]")
+
+            g = fid[1].split(importance_type)[1].split(",")[0].to_f
+
+            fid = fid[0].split("<")[0]
+
+            fmap[fid] ||= 0
+            gmap[fid] ||= 0
+
+            fmap[fid] += 1
+            gmap[fid] += g
+          end
+        end
+
+        if average_over_splits
+          gmap.each_key do |fid|
+            gmap[fid] = gmap[fid] / fmap[fid]
+          end
+        end
+
+        gmap
+      end
+    end
+
     private
 
     def handle_pointer

data/lib/xgb/classifier.rb

@@ -0,0 +1,68 @@
+module Xgb
+  class Classifier
+    def initialize(max_depth: 3, learning_rate: 0.1, n_estimators: 100, objective: "binary:logistic", importance_type: "gain")
+      @params = {
+        max_depth: max_depth,
+        objective: objective,
+        learning_rate: learning_rate
+      }
+      @n_estimators = n_estimators
+      @importance_type = importance_type
+    end
+
+    def fit(x, y)
+      n_classes = y.uniq.size
+
+      params = @params.dup
+      if n_classes > 2
+        params[:objective] = "multi:softprob"
+        params[:num_class] = n_classes
+      end
+
+      dtrain = DMatrix.new(x, label: y)
+      @booster = Xgb.train(params, dtrain, num_boost_round: @n_estimators)
+      nil
+    end
+
+    def predict(data)
+      dmat = DMatrix.new(data)
+      y_pred = @booster.predict(dmat)
+
+      if y_pred.first.is_a?(Array)
+        # multiple classes
+        y_pred.map do |v|
+          v.map.with_index.max_by { |v2, i| v2 }.last
+        end
+      else
+        y_pred.map { |v| v > 0.5 ? 1 : 0 }
+      end
+    end
+
+    def predict_proba(data)
+      dmat = DMatrix.new(data)
+      y_pred = @booster.predict(dmat)
+
+      if y_pred.first.is_a?(Array)
+        # multiple classes
+        y_pred
+      else
+        y_pred.map { |v| [1 - v, v] }
+      end
+    end
+
+    def save_model(fname)
+      @booster.save_model(fname)
+    end
+
+    def load_model(fname)
+      @booster = Booster.new(params: @params, model_file: fname)
+    end
+
+    def feature_importances
+      score = @booster.score(importance_type: @importance_type)
+      scores = @booster.feature_names.map { |k| score[k] || 0.0 }
+      total = scores.sum.to_f
+      scores.map { |s| s / total }
+    end
+  end
+end

data/lib/xgb/dmatrix.rb

@@ -1,24 +1,72 @@
 module Xgb
   class DMatrix
-    attr_reader :data, :label, :weight
+    attr_reader :data
 
     def initialize(data, label: nil, weight: nil, missing: Float::NAN)
       @data = data
-      @label = label
-      @weight = weight
 
-      c_data = ::FFI::MemoryPointer.new(:float, data.count * data.first.count)
-      c_data.put_array_of_float(0, data.flatten)
       @handle = ::FFI::MemoryPointer.new(:pointer)
-      check_result FFI.XGDMatrixCreateFromMat(c_data, data.count, data.first.count, missing, @handle)
+
+      if data
+        if matrix?(data)
+          nrow = data.row_count
+          ncol = data.column_count
+          flat_data = data.to_a.flatten
+        elsif daru?(data)
+          nrow, ncol = data.shape
+          flat_data = data.each_vector.map(&:to_a).flatten
+        elsif narray?(data)
+          nrow, ncol = data.shape
+          flat_data = data.flatten.to_a
+        else
+          nrow = data.count
+          ncol = data.first.count
+          flat_data = data.flatten
+        end
+
+        c_data = ::FFI::MemoryPointer.new(:float, nrow * ncol)
+        c_data.put_array_of_float(0, flat_data)
+        check_result FFI.XGDMatrixCreateFromMat(c_data, nrow, ncol, missing, @handle)
+      end
 
       set_float_info("label", label) if label
+      set_float_info("weight", weight) if weight
+    end
+
+    def label
+      float_info("label")
+    end
+
+    def weight
+      float_info("weight")
+    end
+
+    def num_row
+      out = ::FFI::MemoryPointer.new(:ulong)
+      check_result FFI.XGDMatrixNumRow(handle_pointer, out)
+      out.read_ulong
     end
 
     def num_col
-      out = ::FFI::MemoryPointer.new(:long)
-      FFI.XGDMatrixNumCol(handle_pointer, out)
-      out.read_long
+      out = ::FFI::MemoryPointer.new(:ulong)
+      check_result FFI.XGDMatrixNumCol(handle_pointer, out)
+      out.read_ulong
+    end
+
+    def slice(rindex)
+      res = DMatrix.new(nil)
+      idxset = ::FFI::MemoryPointer.new(:int, rindex.count)
+      idxset.put_array_of_int(0, rindex)
+      check_result FFI.XGDMatrixSliceDMatrix(handle_pointer, idxset, rindex.size, res.handle)
+      res
+    end
+
+    def save_binary(fname, silent: true)
+      check_result FFI.XGDMatrixSaveBinary(handle_pointer, fname, silent ? 1 : 0)
+    end
+
+    def handle
+      @handle
     end
 
     def handle_pointer
@@ -28,11 +76,44 @@ module Xgb
     private
 
     def set_float_info(field, data)
-      c_data = ::FFI::MemoryPointer.new(:float, data.count)
+      data =
+        if matrix?(data)
+          data.to_a[0]
+        elsif daru_vector?(data) || narray?(data)
+          data.to_a
+        else
+          data
+        end
+
+      c_data = ::FFI::MemoryPointer.new(:float, data.size)
       c_data.put_array_of_float(0, data)
       check_result FFI.XGDMatrixSetFloatInfo(handle_pointer, field.to_s, c_data, data.size)
     end
 
+    def float_info(field)
+      num_row ||= num_row()
+      out_len = ::FFI::MemoryPointer.new(:int)
+      out_dptr = ::FFI::MemoryPointer.new(:float, num_row)
+      check_result FFI.XGDMatrixGetFloatInfo(handle_pointer, field, out_len, out_dptr)
+      out_dptr.read_pointer.read_array_of_float(num_row)
+    end
+
+    def matrix?(data)
+      defined?(Matrix) && data.is_a?(Matrix)
+    end
+
+    def daru?(data)
+      defined?(Daru::DataFrame) && data.is_a?(Daru::DataFrame)
+    end
+
+    def daru_vector?(data)
+      defined?(Daru::Vector) && data.is_a?(Daru::Vector)
+    end
+
+    def narray?(data)
+      defined?(Numo::NArray) && data.is_a?(Numo::NArray)
+    end
+
     include Utils
   end
 end

data/lib/xgb/ffi.rb

@@ -10,16 +10,22 @@ module Xgb
     attach_function :XGBGetLastError, %i[], :string
 
     # dmatrix
-    attach_function :XGDMatrixCreateFromMat, %i[pointer long long float pointer], :int
+    attach_function :XGDMatrixCreateFromMat, %i[pointer ulong ulong float pointer], :int
+    attach_function :XGDMatrixNumRow, %i[pointer pointer], :int
     attach_function :XGDMatrixNumCol, %i[pointer pointer], :int
-    attach_function :XGDMatrixSetFloatInfo, %i[pointer string pointer long], :int
+    attach_function :XGDMatrixSliceDMatrix, %i[pointer pointer ulong pointer], :int
+    attach_function :XGDMatrixSaveBinary, %i[pointer string int], :int
+    attach_function :XGDMatrixSetFloatInfo, %i[pointer string pointer ulong], :int
+    attach_function :XGDMatrixGetFloatInfo, %i[pointer string pointer pointer], :int
 
     # booster
     attach_function :XGBoosterCreate, %i[pointer int pointer], :int
     attach_function :XGBoosterUpdateOneIter, %i[pointer int pointer], :int
+    attach_function :XGBoosterEvalOneIter, %i[pointer int pointer pointer ulong pointer], :int
     attach_function :XGBoosterSetParam, %i[pointer string string], :int
     attach_function :XGBoosterPredict, %i[pointer pointer int int pointer pointer], :int
     attach_function :XGBoosterLoadModel, %i[pointer string], :int
     attach_function :XGBoosterSaveModel, %i[pointer string], :int
+    attach_function :XGBoosterDumpModelEx, %i[pointer string int string pointer pointer], :int
   end
 end

data/lib/xgb/regressor.rb

@@ -0,0 +1,39 @@
+module Xgb
+  class Regressor
+    def initialize(max_depth: 3, learning_rate: 0.1, n_estimators: 100, objective: "reg:squarederror", importance_type: "gain")
+      @params = {
+        max_depth: max_depth,
+        objective: objective,
+        learning_rate: learning_rate
+      }
+      @n_estimators = n_estimators
+      @importance_type = importance_type
+    end
+
+    def fit(x, y)
+      dtrain = DMatrix.new(x, label: y)
+      @booster = Xgb.train(@params, dtrain, num_boost_round: @n_estimators)
+      nil
+    end
+
+    def predict(data)
+      dmat = DMatrix.new(data)
+      @booster.predict(dmat)
+    end
+
+    def save_model(fname)
+      @booster.save_model(fname)
+    end
+
+    def load_model(fname)
+      @booster = Booster.new(params: @params, model_file: fname)
+    end
+
+    def feature_importances
+      score = @booster.score(importance_type: @importance_type)
+      scores = @booster.feature_names.map { |k| score[k] || 0.0 }
+      total = scores.sum.to_f
+      scores.map { |s| s / total }
+    end
+  end
+end

data/lib/xgb/utils.rb

@@ -3,7 +3,11 @@ module Xgb
     private
 
     def check_result(err)
-      raise Xgb::Error, FFI.XGBGetLastError if err != 0
+      if err != 0
+        # make friendly
+        message = FFI.XGBGetLastError.split("\n").first.split(/:\d+: /, 2).last
+        raise Xgb::Error, message
+      end
     end
   end
 end

data/lib/xgb/version.rb

@@ -1,3 +1,3 @@
 module Xgb
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xgb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -66,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: daru
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: andrew@chartkick.com
 executables: []
@@ -76,8 +104,10 @@ files:
 - README.md
 - lib/xgb.rb
 - lib/xgb/booster.rb
+- lib/xgb/classifier.rb
 - lib/xgb/dmatrix.rb
 - lib/xgb/ffi.rb
+- lib/xgb/regressor.rb
 - lib/xgb/utils.rb
 - lib/xgb/version.rb
 homepage: https://github.com/ankane/xgb