lightgbm 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7222cd44123f8c35d26b91dbf0288e3d0f7a87e3204a6a501f7590648896d2f
-  data.tar.gz: 2a288731615d9042b0b60184c534bd00d3d64d1d8be1b8dbc2aecb782fd3332b
+  metadata.gz: 49e0eef0a10a444e0cc24c8188268d349037fb12054b3f3f73ab14ed54fae3d7
+  data.tar.gz: 9ee78189ec31bfb3dc9cea6fe5836f97a010097cc821819d05236a899d0654af
 SHA512:
-  metadata.gz: 290d729343c88d2054082692cff9dc948332933439b11915bd507338dc28354fec936b7eded198c8a6bd18d9821ff32d1dccc146c71db7567ddc6037838c0e4b
-  data.tar.gz: 24cd193a72188d43b71cc223d45cc943d710149d42b7ee0fb11eeab8fdf0a9e006ae021313d0881d91cebfbc510a08864721af42f4976e5cd0663ca1a6534f39
+  metadata.gz: d95050754e85ee004df08c4761f31f1bfc97e3efbcd3ea0ae2251f5a84eeff2978e16118411ddeced74a9c7d3fd731176488cbbac4ed2bdd840e55e4dd6172db
+  data.tar.gz: 52dcca52827fffca3d638c814eec359c4f2d397b025cc9ee99323bebbbf5436d3a7fcf569390f0c71eb9623c68a711b0e32ba38a53364873fe9d0de99b2f3f66

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.1.1
+
+- Added training API
+- Added many methods
+
 ## 0.1.0
 
 - First release

data/README.md

@@ -1,10 +1,14 @@
 # LightGBM
 
-LightGBM for Ruby
+[LightGBM](https://github.com/microsoft/LightGBM) for Ruby
+
+:fire: Uses the C API for blazing performance
+
+[![Build Status](https://travis-ci.org/ankane/lightgbm.svg?branch=master)](https://travis-ci.org/ankane/lightgbm)
 
 ## Installation
 
-First, [install LightGBM](https://lightgbm.readthedocs.io/en/latest/Installation-Guide.html).
+First, [install LightGBM](https://lightgbm.readthedocs.io/en/latest/Installation-Guide.html). On Mac, copy `lib_lightgbm.so` to `/usr/local/lib`.
 
 Add this line to your application’s Gemfile:
 
@@ -12,21 +16,65 @@ Add this line to your application’s Gemfile:
 gem 'lightgbm'
 ```
 
-Load a model
+Train a model
 
 ```ruby
-booster = LightGBM::Booster.new(model_file: "model.txt")
+params = {objective: "regression"}
+train_set = LightGBM::Dataset.new(x_train, label: y_train)
+booster = LightGBM.train(params, train_set)
 ```
 
 Predict
 
 ```ruby
-booster.predict([[1, 2], [3, 4]])
+booster.predict(x_test)
+```
+
+Save the model
+
+```ruby
+booster.save_model("model.txt")
+```
+
+Load a model from a file
+
+```ruby
+booster = LightGBM::Booster.new(model_file: "model.txt")
+```
+
+Get feature importance
+
+```ruby
+booster.feature_importance
+```
+
+## Reference
+
+### Booster
+
+```ruby
+booster = LightGBM::Booster.new(model_str: "tree...")
+booster.to_json
+booster.model_to_string
+booster.current_iteration
+```
+
+### Dataset
+
+```ruby
+dataset = LightGBM::Dataset.new(data, label: label, weight: weight, params: params)
+dataset.num_data
+dataset.num_feature
+
+# note: only works with unquoted CSVs
+dataset = LightGBM::Dataset.new("data.csv", params: {headers: true, label: "name:label"})
+dataset.save_binary("train.bin")
+dataset.dump_text("train.txt")
 ```
 
 ## Credits
 
-Thanks to the [xgboost](https://github.com/PairOnAir/xgboost-ruby) gem for serving as an initial reference.
+Thanks to the [xgboost](https://github.com/PairOnAir/xgboost-ruby) gem for serving as an initial reference, and Selva Prabhakaran for the [test datasets](https://github.com/selva86/datasets).
 
 ## History
 

data/lib/lightgbm.rb

@@ -2,6 +2,23 @@
 require "ffi"
 
 # modules
+require "lightgbm/utils"
 require "lightgbm/booster"
+require "lightgbm/dataset"
 require "lightgbm/ffi"
 require "lightgbm/version"
+
+module LightGBM
+  class Error < StandardError; end
+
+  def self.train(params, train_set, num_boost_round: 100, valid_sets: [], valid_names: [])
+    booster = Booster.new(params: params, train_set: train_set)
+    valid_sets.zip(valid_names) do |data, name|
+      booster.add_valid(data, name)
+    end
+    num_boost_round.times do
+      booster.update
+    end
+    booster
+  end
+end

data/lib/lightgbm/booster.rb

@@ -1,18 +1,30 @@
 module LightGBM
   class Booster
-    def initialize(model_file:)
+    def initialize(params: nil, train_set: nil, model_file: nil, model_str: nil)
       @handle = ::FFI::MemoryPointer.new(:pointer)
-      if model_file
+      if model_str
+        out_num_iterations = ::FFI::MemoryPointer.new(:int)
+        check_result FFI.LGBM_BoosterLoadModelFromString(model_str, out_num_iterations, @handle)
+      elsif model_file
         out_num_iterations = ::FFI::MemoryPointer.new(:int)
         check_result FFI.LGBM_BoosterCreateFromModelfile(model_file, out_num_iterations, @handle)
+      else
+        check_result FFI.LGBM_BoosterCreate(train_set.handle_pointer, params_str(params), @handle)
       end
-      ObjectSpace.define_finalizer(self, self.class.finalize(handle_pointer))
+      # causes "Stack consistency error"
+      # ObjectSpace.define_finalizer(self, self.class.finalize(handle_pointer))
     end
 
     def self.finalize(pointer)
       -> { FFI.LGBM_BoosterFree(pointer) }
     end
 
+    # TODO handle name
+    def add_valid(data, name)
+      check_result FFI.LGBM_BoosterAddValidData(handle_pointer, data.handle_pointer)
+      self # consistent with Python API
+    end
+
     def predict(input)
       raise TypeError unless input.is_a?(Array)
 
@@ -31,16 +43,86 @@ module LightGBM
       singular ? out : out.first
     end
 
-    private
+    def save_model(filename)
+      check_result FFI.LGBM_BoosterSaveModel(handle_pointer, 0, 0, filename)
+      self # consistent with Python API
+    end
+
+    def update
+      finished = ::FFI::MemoryPointer.new(:int)
+      check_result FFI.LGBM_BoosterUpdateOneIter(handle_pointer, finished)
+      finished.read_int == 1
+    end
+
+    def feature_importance(iteration: nil, importance_type: "split")
+      iteration ||= best_iteration
+      importance_type =
+        case importance_type
+        when "split"
+          0
+        when "gain"
+          1
+        else
+          -1
+        end
+
+      num_features = self.num_features
+      out_result = ::FFI::MemoryPointer.new(:double, num_features)
+      check_result FFI.LGBM_BoosterFeatureImportance(handle_pointer, iteration, importance_type, out_result)
+      out_result.read_array_of_double(num_features)
+    end
+
+    def num_features
+      out = ::FFI::MemoryPointer.new(:int)
+      check_result FFI.LGBM_BoosterGetNumFeature(handle_pointer, out)
+      out.read_int
+    end
 
-    def check_result(err)
-      if err != 0
-        raise FFI.LGBM_GetLastError
+    def current_iteration
+      out = ::FFI::MemoryPointer.new(:int)
+      check_result FFI::LGBM_BoosterGetCurrentIteration(handle_pointer, out)
+      out.read_int
+    end
+
+    # TODO fix
+    def best_iteration
+      -1
+    end
+
+    def model_to_string(num_iteration: nil, start_iteration: 0)
+      num_iteration ||= best_iteration
+      buffer_len = 1 << 20
+      out_len = ::FFI::MemoryPointer.new(:int64)
+      out_str = ::FFI::MemoryPointer.new(:string, buffer_len)
+      check_result FFI.LGBM_BoosterSaveModelToString(handle_pointer, start_iteration, num_iteration, buffer_len, out_len, out_str)
+      actual_len = out_len.read_int64
+      if actual_len > buffer_len
+        out_str = ::FFI::MemoryPointer.new(:string, actual_len)
+        check_result FFI.LGBM_BoosterSaveModelToString(handle_pointer, start_iteration, num_iteration, actual_len, out_len, out_str)
+      end
+      out_str.read_string
+    end
+
+    def to_json(num_iteration: nil, start_iteration: 0)
+      num_iteration ||= best_iteration
+      buffer_len = 1 << 20
+      out_len = ::FFI::MemoryPointer.new(:int64)
+      out_str = ::FFI::MemoryPointer.new(:string, buffer_len)
+      check_result FFI.LGBM_BoosterDumpModel(handle_pointer, start_iteration, num_iteration, buffer_len, out_len, out_str)
+      actual_len = out_len.read_int64
+      if actual_len > buffer_len
+        out_str = ::FFI::MemoryPointer.new(:string, actual_len)
+        check_result FFI.LGBM_BoosterDumpModel(handle_pointer, start_iteration, num_iteration, actual_len, out_len, out_str)
       end
+      out_str.read_string
     end
 
+    private
+
     def handle_pointer
       @handle.read_pointer
     end
+
+    include Utils
   end
 end

data/lib/lightgbm/dataset.rb

@@ -0,0 +1,78 @@
+module LightGBM
+  class Dataset
+    attr_reader :data, :params
+
+    def initialize(data, label: nil, weight: nil, params: nil)
+      @data = data
+
+      @handle = ::FFI::MemoryPointer.new(:pointer)
+      if data.is_a?(String)
+        check_result FFI.LGBM_DatasetCreateFromFile(data, params_str(params), nil, @handle)
+      else
+        c_data = ::FFI::MemoryPointer.new(:float, data.count * data.first.count)
+        c_data.put_array_of_float(0, data.flatten)
+        check_result FFI.LGBM_DatasetCreateFromMat(c_data, 0, data.count, data.first.count, 1, params_str(params), nil, @handle)
+      end
+      # causes "Stack consistency error"
+      # ObjectSpace.define_finalizer(self, self.class.finalize(handle_pointer))
+
+      set_field("label", label) if label
+      set_field("weight", weight) if weight
+    end
+
+    def label
+      field("label")
+    end
+
+    def weight
+      field("weight")
+    end
+
+    def num_data
+      out = ::FFI::MemoryPointer.new(:int)
+      check_result FFI.LGBM_DatasetGetNumData(handle_pointer, out)
+      out.read_int
+    end
+
+    def num_feature
+      out = ::FFI::MemoryPointer.new(:int)
+      check_result FFI.LGBM_DatasetGetNumFeature(handle_pointer, out)
+      out.read_int
+    end
+
+    def save_binary(filename)
+      check_result FFI.LGBM_DatasetSaveBinary(handle_pointer, filename)
+    end
+
+    def dump_text(filename)
+      check_result FFI.LGBM_DatasetDumpText(handle_pointer, filename)
+    end
+
+    def self.finalize(pointer)
+      -> { FFI.LGBM_DatasetFree(pointer) }
+    end
+
+    def handle_pointer
+      @handle.read_pointer
+    end
+
+    private
+
+    def field(field_name)
+      num_data = self.num_data
+      out_len = ::FFI::MemoryPointer.new(:int)
+      out_ptr = ::FFI::MemoryPointer.new(:float, num_data)
+      out_type = ::FFI::MemoryPointer.new(:int)
+      check_result FFI.LGBM_DatasetGetField(handle_pointer, field_name, out_len, out_ptr, out_type)
+      out_ptr.read_pointer.read_array_of_float(num_data)
+    end
+
+    def set_field(field_name, data)
+      c_data = ::FFI::MemoryPointer.new(:float, data.count)
+      c_data.put_array_of_float(0, data)
+      check_result FFI.LGBM_DatasetSetField(handle_pointer, field_name, c_data, data.count, 0)
+    end
+
+    include Utils
+  end
+end

data/lib/lightgbm/ffi.rb

@@ -4,10 +4,35 @@ module LightGBM
     ffi_lib ["lightgbm", "lib_lightgbm.so"]
 
     # https://github.com/microsoft/LightGBM/blob/master/include/LightGBM/c_api.h
+    # keep same order
+
+    # error
     attach_function :LGBM_GetLastError, %i[], :string
+
+    # dataset
+    attach_function :LGBM_DatasetCreateFromFile, %i[string string pointer pointer], :int
+    attach_function :LGBM_DatasetCreateFromMat, %i[pointer int int32 int32 int string pointer pointer], :int
+    attach_function :LGBM_DatasetFree, %i[pointer], :int
+    attach_function :LGBM_DatasetSaveBinary, %i[pointer string], :int
+    attach_function :LGBM_DatasetDumpText, %i[pointer string], :int
+    attach_function :LGBM_DatasetSetField, %i[pointer string pointer int int], :int
+    attach_function :LGBM_DatasetGetField, %i[pointer string pointer pointer pointer], :int
+    attach_function :LGBM_DatasetGetNumData, %i[pointer pointer], :int
+    attach_function :LGBM_DatasetGetNumFeature, %i[pointer pointer], :int
+
+    # booster
     attach_function :LGBM_BoosterCreate, %i[pointer string pointer], :int
     attach_function :LGBM_BoosterCreateFromModelfile, %i[string pointer pointer], :int
+    attach_function :LGBM_BoosterLoadModelFromString, %i[string pointer pointer], :int
     attach_function :LGBM_BoosterFree, %i[pointer], :int
+    attach_function :LGBM_BoosterAddValidData, %i[pointer pointer], :int
+    attach_function :LGBM_BoosterUpdateOneIter, %i[pointer pointer], :int
+    attach_function :LGBM_BoosterGetCurrentIteration, %i[pointer pointer], :int
+    attach_function :LGBM_BoosterGetNumFeature, %i[pointer pointer], :int
     attach_function :LGBM_BoosterPredictForMat, %i[pointer pointer int int32 int32 int int int string pointer pointer], :int
+    attach_function :LGBM_BoosterSaveModel, %i[pointer int int string], :int
+    attach_function :LGBM_BoosterSaveModelToString, %i[pointer int int int64 pointer pointer], :int
+    attach_function :LGBM_BoosterDumpModel, %i[pointer int int int64 pointer pointer], :int
+    attach_function :LGBM_BoosterFeatureImportance, %i[pointer int int pointer], :int
   end
 end

data/lib/lightgbm/utils.rb

@@ -0,0 +1,19 @@
+module LightGBM
+  module Utils
+    private
+
+    def check_result(err)
+      raise LightGBM::Error, FFI.LGBM_GetLastError if err != 0
+    end
+
+    # remove spaces in keys and values to prevent injection
+    def params_str(params)
+      (params || {}).map { |k, v| [check_param(k.to_s), check_param(v.to_s)].join("=") }.join(" ")
+    end
+
+    def check_param(v)
+      raise ArgumentError, "Invalid parameter" if /[[:space:]]/.match(v)
+      v
+    end
+  end
+end

data/lib/lightgbm/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lightgbm
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Andrew Kane
@@ -76,7 +76,9 @@ files:
 - README.md
 - lib/lightgbm.rb
 - lib/lightgbm/booster.rb
+- lib/lightgbm/dataset.rb
 - lib/lightgbm/ffi.rb
+- lib/lightgbm/utils.rb
 - lib/lightgbm/version.rb
 homepage: https://github.com/ankane/lightgbm
 licenses: