lightgbm 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 260da517ea054bb9de47d8e1f1ee6ece133bfae733da24ab943e9387a2a99f10
-  data.tar.gz: a9a9a94153f21a6d085ca5ce10a973b71dc81f1710d4b2afbab5c4caf3302d65
+  metadata.gz: 4fadfa7ea250cf7c48f076effb5ce8f5db3cf0c8ab87bb04f2033457a502721a
+  data.tar.gz: 3af4cac369a3c684bdb387036845eca04747c14c8e12c9b38625e5c38130de74
 SHA512:
-  metadata.gz: a95afda36a019f80afdaeb3a55c2bfa4e8a93988f155e546f0f2b98be33ba58a295fb31cc1643c9cd95576d5fabc37a5ed28fb6a0d1b13cf3be56dab4d9d0ba0
-  data.tar.gz: 77021a65a856a645c2715460a0285937483b46a889d18c07ce8cf097a8c9176595767c3b32d33a03e8ee6f5c785f20e8817e5ddb3e98629297e5973a8673c0a7
+  metadata.gz: 21fb7ae25e1f085cd3642bb02ce32f8378f5d6013f6e8504b86586c86dfaf5c29b12d83b10e3bfd747a3dbfc996eb8473c12313ca5e2f4302554b0a6c40261e3
+  data.tar.gz: 75d7b3cea373adedbe8a6cc7c9f0b47f473ac0e77126779efd2f5ab1899596f4a8a926e1d97b033e5cb6e43b0c0f3706e8e7eb9f280d29354ba18792e2f4078b

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 0.4.0 (2025-01-05)
+
+- Added support for different prediction types
+- Added support for `pandas_categorical` to `predict` method
+- Added support for hashes and Rover data frames to `predict` method
+- Added support for hashes to `Dataset`
+- Added `importance_type` option to `dump_model`, `model_to_string`, and `save_model` methods
+- Changed `Dataset` to use column names for feature names with Rover and Daru
+- Changed `predict` method to match feature names with Daru
+- Dropped support for Ruby < 3.1
+
 ## 0.3.4 (2024-07-28)
 
 - Updated LightGBM to 4.5.0

data/LICENSE.txt

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
 Copyright (c) Microsoft Corporation
-Copyright (c) 2019-2023 Andrew Kane
+Copyright (c) 2019-2025 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/lib/lightgbm/booster.rb

@@ -1,20 +1,29 @@
 module LightGBM
   class Booster
-    attr_accessor :best_iteration, :train_data_name
+    include Utils
+
+    attr_accessor :best_iteration, :train_data_name, :params
 
     def initialize(params: nil, train_set: nil, model_file: nil, model_str: nil)
-      @handle = ::FFI::MemoryPointer.new(:pointer)
       if model_str
         model_from_string(model_str)
       elsif model_file
         out_num_iterations = ::FFI::MemoryPointer.new(:int)
-        check_result FFI.LGBM_BoosterCreateFromModelfile(model_file, out_num_iterations, @handle)
+        create_handle do |handle|
+          safe_call FFI.LGBM_BoosterCreateFromModelfile(model_file, out_num_iterations, handle)
+        end
+        @pandas_categorical = load_pandas_categorical(file_name: model_file)
+        if params
+          warn "[lightgbm] Ignoring params argument, using parameters from model file."
+        end
+        @params = loaded_param
       else
         params ||= {}
         set_verbosity(params)
-        check_result FFI.LGBM_BoosterCreate(train_set.handle_pointer, params_str(params), @handle)
+        create_handle do |handle|
+          safe_call FFI.LGBM_BoosterCreate(train_set.handle, params_str(params), handle)
+        end
       end
-      ObjectSpace.define_finalizer(@handle, self.class.finalize(handle_pointer.to_i))
 
       self.best_iteration = -1
 
@@ -23,28 +32,28 @@ module LightGBM
     end
 
     def add_valid(data, name)
-      check_result FFI.LGBM_BoosterAddValidData(handle_pointer, data.handle_pointer)
+      safe_call FFI.LGBM_BoosterAddValidData(@handle, data.handle)
       @name_valid_sets << name
       self # consistent with Python API
     end
 
     def current_iteration
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterGetCurrentIteration(handle_pointer, out)
+      safe_call FFI.LGBM_BoosterGetCurrentIteration(@handle, out)
       out.read_int
     end
 
-    def dump_model(num_iteration: nil, start_iteration: 0)
+    def dump_model(num_iteration: nil, start_iteration: 0, importance_type: "split")
       num_iteration ||= best_iteration
+      importance_type_int = feature_importance_type_mapper(importance_type)
       buffer_len = 1 << 20
       out_len = ::FFI::MemoryPointer.new(:int64)
       out_str = ::FFI::MemoryPointer.new(:char, buffer_len)
-      feature_importance_type = 0 # TODO add option
-      check_result FFI.LGBM_BoosterDumpModel(handle_pointer, start_iteration, num_iteration, feature_importance_type, buffer_len, out_len, out_str)
-      actual_len = read_int64(out_len)
+      safe_call FFI.LGBM_BoosterDumpModel(@handle, start_iteration, num_iteration, importance_type_int, buffer_len, out_len, out_str)
+      actual_len = out_len.read_int64
       if actual_len > buffer_len
         out_str = ::FFI::MemoryPointer.new(:char, actual_len)
-        check_result FFI.LGBM_BoosterDumpModel(handle_pointer, start_iteration, num_iteration, feature_importance_type, actual_len, out_len, out_str)
+        safe_call FFI.LGBM_BoosterDumpModel(@handle, start_iteration, num_iteration, importance_type_int, actual_len, out_len, out_str)
       end
       out_str.read_string
     end
@@ -60,19 +69,10 @@ module LightGBM
 
     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
-
+      importance_type_int = feature_importance_type_mapper(importance_type)
       num_feature = self.num_feature
       out_result = ::FFI::MemoryPointer.new(:double, num_feature)
-      check_result FFI.LGBM_BoosterFeatureImportance(handle_pointer, iteration, importance_type, out_result)
+      safe_call FFI.LGBM_BoosterFeatureImportance(@handle, iteration, importance_type_int, out_result)
       out_result.read_array_of_double(num_feature).map(&:to_i)
     end
 
@@ -84,13 +84,13 @@ module LightGBM
       out_strs = ::FFI::MemoryPointer.new(:pointer, num_feature)
       str_ptrs = len.times.map { ::FFI::MemoryPointer.new(:char, buffer_len) }
       out_strs.write_array_of_pointer(str_ptrs)
-      check_result FFI.LGBM_BoosterGetFeatureNames(handle_pointer, len, out_len, buffer_len, out_buffer_len, out_strs)
+      safe_call FFI.LGBM_BoosterGetFeatureNames(@handle, len, out_len, buffer_len, out_buffer_len, out_strs)
 
       actual_len = out_buffer_len.read(:size_t)
       if actual_len > buffer_len
         str_ptrs = len.times.map { ::FFI::MemoryPointer.new(:char, actual_len) }
         out_strs.write_array_of_pointer(str_ptrs)
-        check_result FFI.LGBM_BoosterGetFeatureNames(handle_pointer, len, out_len, actual_len, out_buffer_len, out_strs)
+        safe_call FFI.LGBM_BoosterGetFeatureNames(@handle, len, out_len, actual_len, out_buffer_len, out_strs)
       end
 
       str_ptrs[0, out_len.read(:size_t)].map(&:read_string)
@@ -98,130 +98,122 @@ module LightGBM
 
     def model_from_string(model_str)
       out_num_iterations = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterLoadModelFromString(model_str, out_num_iterations, @handle)
+      create_handle do |handle|
+        safe_call FFI.LGBM_BoosterLoadModelFromString(model_str, out_num_iterations, handle)
+      end
+      @pandas_categorical = load_pandas_categorical(model_str: model_str)
+      @params = loaded_param
+      @cached_feature_name = nil
       self
     end
 
-    def model_to_string(num_iteration: nil, start_iteration: 0)
+    def model_to_string(num_iteration: nil, start_iteration: 0, importance_type: "split")
       num_iteration ||= best_iteration
+      importance_type_int = feature_importance_type_mapper(importance_type)
       buffer_len = 1 << 20
       out_len = ::FFI::MemoryPointer.new(:int64)
       out_str = ::FFI::MemoryPointer.new(:char, buffer_len)
-      feature_importance_type = 0 # TODO add option
-      check_result FFI.LGBM_BoosterSaveModelToString(handle_pointer, start_iteration, num_iteration, feature_importance_type, buffer_len, out_len, out_str)
-      actual_len = read_int64(out_len)
+      safe_call FFI.LGBM_BoosterSaveModelToString(@handle, start_iteration, num_iteration, importance_type_int, buffer_len, out_len, out_str)
+      actual_len = out_len.read_int64
       if actual_len > buffer_len
         out_str = ::FFI::MemoryPointer.new(:char, actual_len)
-        check_result FFI.LGBM_BoosterSaveModelToString(handle_pointer, start_iteration, num_iteration, feature_importance_type, actual_len, out_len, out_str)
+        safe_call FFI.LGBM_BoosterSaveModelToString(@handle, start_iteration, num_iteration, importance_type_int, actual_len, out_len, out_str)
       end
       out_str.read_string
     end
 
     def num_feature
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterGetNumFeature(handle_pointer, out)
+      safe_call FFI.LGBM_BoosterGetNumFeature(@handle, out)
       out.read_int
     end
     alias_method :num_features, :num_feature # legacy typo
 
     def num_model_per_iteration
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterNumModelPerIteration(handle_pointer, out)
+      safe_call FFI.LGBM_BoosterNumModelPerIteration(@handle, out)
       out.read_int
     end
 
     def num_trees
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterNumberOfTotalModel(handle_pointer, out)
+      safe_call FFI.LGBM_BoosterNumberOfTotalModel(@handle, out)
       out.read_int
     end
 
-    # TODO support different prediction types
-    def predict(input, start_iteration: nil, num_iteration: nil, **params)
-      input =
-        if daru?(input)
-          input.map_rows(&:to_a)
+    def predict(data, start_iteration: 0, num_iteration: nil, raw_score: false, pred_leaf: false, pred_contrib: false, **kwargs)
+      predictor = InnerPredictor.from_booster(self, kwargs.transform_values(&:dup))
+      if num_iteration.nil?
+        if start_iteration <= 0
+          num_iteration = best_iteration
         else
-          input.to_a
+          num_iteration = -1
         end
-
-      singular = !input.first.is_a?(Array)
-      input = [input] if singular
-
-      start_iteration ||= 0
-      num_iteration ||= best_iteration
-      num_class ||= num_class()
-
-      flat_input = input.flatten
-      handle_missing(flat_input)
-      data = ::FFI::MemoryPointer.new(:double, input.count * input.first.count)
-      data.write_array_of_double(flat_input)
-
-      out_len = ::FFI::MemoryPointer.new(:int64)
-      out_result = ::FFI::MemoryPointer.new(:double, num_class * input.count)
-      check_result FFI.LGBM_BoosterPredictForMat(handle_pointer, data, 1, input.count, input.first.count, 1, 0, start_iteration, num_iteration, params_str(params), out_len, out_result)
-      out = out_result.read_array_of_double(read_int64(out_len))
-      out = out.each_slice(num_class).to_a if num_class > 1
-
-      singular ? out.first : out
+      end
+      predictor.predict(
+        data,
+        start_iteration: start_iteration,
+        num_iteration: num_iteration,
+        raw_score: raw_score,
+        pred_leaf: pred_leaf,
+        pred_contrib: pred_contrib
+      )
     end
 
-    def save_model(filename, num_iteration: nil, start_iteration: 0)
+    def save_model(filename, num_iteration: nil, start_iteration: 0, importance_type: "split")
       num_iteration ||= best_iteration
-      feature_importance_type = 0 # TODO add
-      check_result FFI.LGBM_BoosterSaveModel(handle_pointer, start_iteration, num_iteration, feature_importance_type, filename)
+      importance_type_int = feature_importance_type_mapper(importance_type)
+      safe_call FFI.LGBM_BoosterSaveModel(@handle, start_iteration, num_iteration, importance_type_int, filename)
       self # consistent with Python API
     end
 
     def update
       finished = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterUpdateOneIter(handle_pointer, finished)
+      safe_call FFI.LGBM_BoosterUpdateOneIter(@handle, finished)
       finished.read_int == 1
     end
 
-    def self.finalize(addr)
-      # must use proc instead of stabby lambda
-      proc { FFI.LGBM_BoosterFree(::FFI::Pointer.new(:pointer, addr)) }
-    end
-
     private
 
-    def handle_pointer
-      @handle.read_pointer
+    def create_handle
+      ::FFI::MemoryPointer.new(:pointer) do |handle|
+        yield handle
+        @handle = ::FFI::AutoPointer.new(handle.read_pointer, FFI.method(:LGBM_BoosterFree))
+      end
     end
 
     def eval_counts
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterGetEvalCounts(handle_pointer, out)
+      safe_call FFI.LGBM_BoosterGetEvalCounts(@handle, out)
       out.read_int
     end
 
     def eval_names
-      eval_counts ||= eval_counts()
+      eval_counts = self.eval_counts
       out_len = ::FFI::MemoryPointer.new(:int)
       out_buffer_len = ::FFI::MemoryPointer.new(:size_t)
       out_strs = ::FFI::MemoryPointer.new(:pointer, eval_counts)
       buffer_len = 255
       str_ptrs = eval_counts.times.map { ::FFI::MemoryPointer.new(:char, buffer_len) }
       out_strs.write_array_of_pointer(str_ptrs)
-      check_result FFI.LGBM_BoosterGetEvalNames(handle_pointer, eval_counts, out_len, buffer_len, out_buffer_len, out_strs)
+      safe_call FFI.LGBM_BoosterGetEvalNames(@handle, eval_counts, out_len, buffer_len, out_buffer_len, out_strs)
 
       actual_len = out_buffer_len.read(:size_t)
       if actual_len > buffer_len
         str_ptrs = eval_counts.times.map { ::FFI::MemoryPointer.new(:char, actual_len) }
         out_strs.write_array_of_pointer(str_ptrs)
-        check_result FFI.LGBM_BoosterGetEvalNames(handle_pointer, eval_counts, out_len, actual_len, out_buffer_len, out_strs)
+        safe_call FFI.LGBM_BoosterGetEvalNames(@handle, eval_counts, out_len, actual_len, out_buffer_len, out_strs)
       end
 
       str_ptrs.map(&:read_string)
     end
 
     def inner_eval(name, i)
-      eval_names ||= eval_names()
+      eval_names = self.eval_names
 
       out_len = ::FFI::MemoryPointer.new(:int)
       out_results = ::FFI::MemoryPointer.new(:double, eval_names.count)
-      check_result FFI.LGBM_BoosterGetEval(handle_pointer, i, out_len, out_results)
+      safe_call FFI.LGBM_BoosterGetEval(@handle, i, out_len, out_results)
       vals = out_results.read_array_of_double(out_len.read_int)
 
       eval_names.zip(vals).map do |eval_name, val|
@@ -232,15 +224,66 @@ module LightGBM
 
     def num_class
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_BoosterGetNumClasses(handle_pointer, out)
+      safe_call FFI.LGBM_BoosterGetNumClasses(@handle, out)
       out.read_int
     end
 
-    # read_int64 not available on JRuby
-    def read_int64(ptr)
-      ptr.read_array_of_int64(1).first
+    def cached_feature_name
+      @cached_feature_name ||= feature_name
     end
 
-    include Utils
+    def feature_importance_type_mapper(importance_type)
+      case importance_type
+      when "split"
+        FFI::C_API_FEATURE_IMPORTANCE_SPLIT
+      when "gain"
+        FFI::C_API_FEATURE_IMPORTANCE_GAIN
+      else
+        -1
+      end
+    end
+
+    def load_pandas_categorical(file_name: nil, model_str: nil)
+      pandas_key = "pandas_categorical:"
+      offset = -pandas_key.length
+      if !file_name.nil?
+        max_offset = -File.size(file_name)
+        lines = []
+        File.open(file_name, "rb") do |f|
+          loop do
+            offset = [offset, max_offset].max
+            f.seek(offset, IO::SEEK_END)
+            lines = f.readlines
+            if lines.length >= 2 || offset == max_offset
+              break
+            end
+            offset *= 2
+          end
+        end
+        last_line = lines[-1].strip
+        if !last_line.start_with?(pandas_key)
+          last_line = lines[-2].strip
+        end
+      elsif !model_str.nil?
+        idx = model_str[..offset].rindex("\n")
+        last_line = model_str[idx..].strip
+      end
+      if last_line.start_with?(pandas_key)
+        JSON.parse(last_line[pandas_key.length..])
+      end
+    end
+
+    def loaded_param
+      buffer_len = 1 << 20
+      out_len = ::FFI::MemoryPointer.new(:int64)
+      out_str = ::FFI::MemoryPointer.new(:char, buffer_len)
+      safe_call FFI.LGBM_BoosterGetLoadedParam(@handle, buffer_len, out_len, out_str)
+      actual_len = out_len.read_int64
+      if actual_len > buffer_len
+        out_str = ::FFI::MemoryPointer.new(:char, actual_len)
+        safe_call FFI.LGBM_BoosterGetLoadedParam(@handle, actual_len, out_len, out_str)
+      end
+      JSON.parse(out_str.read_string)
+    end
   end
 end

data/lib/lightgbm/dataset.rb

@@ -1,8 +1,10 @@
 module LightGBM
   class Dataset
+    include Utils
+
     attr_reader :data, :params
 
-    def initialize(data, label: nil, weight: nil, group: nil, params: nil, reference: nil, used_indices: nil, categorical_feature: "auto", feature_names: nil)
+    def initialize(data, label: nil, weight: nil, group: nil, params: nil, reference: nil, used_indices: nil, categorical_feature: "auto", feature_name: nil, feature_names: nil)
       @data = data
       @label = label
       @weight = weight
@@ -11,7 +13,7 @@ module LightGBM
       @reference = reference
       @used_indices = used_indices
       @categorical_feature = categorical_feature
-      @feature_names = feature_names
+      @feature_name = feature_name || feature_names || "auto"
 
       construct
     end
@@ -24,7 +26,7 @@ module LightGBM
       field("weight")
     end
 
-    def feature_names
+    def feature_name
       # must preallocate space
       num_feature_names = ::FFI::MemoryPointer.new(:int)
       out_buffer_len = ::FFI::MemoryPointer.new(:size_t)
@@ -33,7 +35,7 @@ module LightGBM
       buffer_len = 255
       str_ptrs = len.times.map { ::FFI::MemoryPointer.new(:char, buffer_len) }
       out_strs.write_array_of_pointer(str_ptrs)
-      check_result FFI.LGBM_DatasetGetFeatureNames(handle_pointer, len, num_feature_names, buffer_len, out_buffer_len, out_strs)
+      safe_call FFI.LGBM_DatasetGetFeatureNames(@handle, len, num_feature_names, buffer_len, out_buffer_len, out_strs)
 
       num_features = num_feature_names.read_int
       actual_len = out_buffer_len.read(:size_t)
@@ -41,13 +43,14 @@ module LightGBM
         out_strs = ::FFI::MemoryPointer.new(:pointer, num_features) if num_features > len
         str_ptrs = num_features.times.map { ::FFI::MemoryPointer.new(:char, actual_len) }
         out_strs.write_array_of_pointer(str_ptrs)
-        check_result FFI.LGBM_DatasetGetFeatureNames(handle_pointer, num_features, num_feature_names, actual_len, out_buffer_len, out_strs)
+        safe_call FFI.LGBM_DatasetGetFeatureNames(@handle, num_features, num_feature_names, actual_len, out_buffer_len, out_strs)
       end
 
       # should be the same, but get number of features
       # from most recent call (instead of num_features)
       str_ptrs[0, num_feature_names.read_int].map(&:read_string)
     end
+    alias_method :feature_names, :feature_name
 
     def label=(label)
       @label = label
@@ -64,12 +67,16 @@ module LightGBM
       set_field("group", group, type: :int32)
     end
 
-    def feature_names=(feature_names)
+    def feature_name=(feature_names)
+      feature_names = feature_names.map(&:to_s)
       @feature_names = feature_names
       c_feature_names = ::FFI::MemoryPointer.new(:pointer, feature_names.size)
-      c_feature_names.write_array_of_pointer(feature_names.map { |v| ::FFI::MemoryPointer.from_string(v) })
-      check_result FFI.LGBM_DatasetSetFeatureNames(handle_pointer, c_feature_names, feature_names.size)
+      # keep reference to string pointers
+      str_ptrs = feature_names.map { |v| ::FFI::MemoryPointer.from_string(v) }
+      c_feature_names.write_array_of_pointer(str_ptrs)
+      safe_call FFI.LGBM_DatasetSetFeatureNames(@handle, c_feature_names, feature_names.size)
     end
+    alias_method :feature_names=, :feature_name=
 
     # TODO only update reference if not in chain
     def reference=(reference)
@@ -81,18 +88,18 @@ module LightGBM
 
     def num_data
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_DatasetGetNumData(handle_pointer, out)
+      safe_call FFI.LGBM_DatasetGetNumData(@handle, out)
       out.read_int
     end
 
     def num_feature
       out = ::FFI::MemoryPointer.new(:int)
-      check_result FFI.LGBM_DatasetGetNumFeature(handle_pointer, out)
+      safe_call FFI.LGBM_DatasetGetNumFeature(@handle, out)
       out.read_int
     end
 
     def save_binary(filename)
-      check_result FFI.LGBM_DatasetSaveBinary(handle_pointer, filename)
+      safe_call FFI.LGBM_DatasetSaveBinary(@handle, filename)
     end
 
     def subset(used_indices, params: nil)
@@ -105,13 +112,8 @@ module LightGBM
       )
     end
 
-    def handle_pointer
-      @handle.read_pointer
-    end
-
-    def self.finalize(addr)
-      # must use proc instead of stabby lambda
-      proc { FFI.LGBM_DatasetFree(::FFI::Pointer.new(:pointer, addr)) }
+    def handle
+      @handle
     end
 
     private
@@ -127,27 +129,45 @@ module LightGBM
       end
       set_verbosity(params)
 
-      @handle = ::FFI::MemoryPointer.new(:pointer)
+      handle = ::FFI::MemoryPointer.new(:pointer)
       parameters = params_str(params)
-      reference = @reference.handle_pointer if @reference
+      reference = @reference.handle if @reference
       if used_indices
         used_row_indices = ::FFI::MemoryPointer.new(:int32, used_indices.count)
         used_row_indices.write_array_of_int32(used_indices)
-        check_result FFI.LGBM_DatasetGetSubset(reference, used_row_indices, used_indices.count, parameters, @handle)
+        safe_call FFI.LGBM_DatasetGetSubset(reference, used_row_indices, used_indices.count, parameters, handle)
       elsif data.is_a?(String)
-        check_result FFI.LGBM_DatasetCreateFromFile(data, parameters, reference, @handle)
+        safe_call FFI.LGBM_DatasetCreateFromFile(data, parameters, reference, handle)
       else
         if matrix?(data)
           nrow = data.row_count
           ncol = data.column_count
           flat_data = data.to_a.flatten
         elsif daru?(data)
+          if @feature_name == "auto"
+            @feature_name = data.vectors.to_a
+          end
           nrow, ncol = data.shape
           flat_data = data.map_rows(&:to_a).flatten
-        elsif numo?(data) || rover?(data)
-          data = data.to_numo if rover?(data)
+        elsif numo?(data)
+          nrow, ncol = data.shape
+        elsif rover?(data)
+          if @feature_name == "auto"
+            @feature_name = data.keys
+          end
+          data = data.to_numo
           nrow, ncol = data.shape
+        elsif data.is_a?(Array) && data.first.is_a?(Hash)
+          keys = data.first.keys
+          if @feature_name == "auto"
+            @feature_name = keys
+          end
+          nrow = data.count
+          ncol = data.first.count
+          flat_data = data.flat_map { |v| v.fetch_values(*keys) }
         else
+          data = data.to_a
+          check_2d_array(data)
           nrow = data.count
           ncol = data.first.count
           flat_data = data.flatten
@@ -161,18 +181,22 @@ module LightGBM
           c_data.write_array_of_double(flat_data)
         end
 
-        check_result FFI.LGBM_DatasetCreateFromMat(c_data, 1, nrow, ncol, 1, parameters, reference, @handle)
+        safe_call FFI.LGBM_DatasetCreateFromMat(c_data, FFI::C_API_DTYPE_FLOAT64, nrow, ncol, 1, parameters, reference, handle)
+      end
+      if used_indices
+        @handle = handle.read_pointer
+      else
+        @handle = ::FFI::AutoPointer.new(handle.read_pointer, FFI.method(:LGBM_DatasetFree))
       end
-      ObjectSpace.define_finalizer(@handle, self.class.finalize(handle_pointer.to_i)) unless used_indices
 
       self.label = @label if @label
       self.weight = @weight if @weight
       self.group = @group if @group
-      self.feature_names = @feature_names if @feature_names
+      self.feature_name = @feature_name if @feature_name && @feature_name != "auto"
     end
 
     def dump_text(filename)
-      check_result FFI.LGBM_DatasetDumpText(handle_pointer, filename)
+      safe_call FFI.LGBM_DatasetDumpText(@handle, filename)
     end
 
     def field(field_name)
@@ -180,7 +204,7 @@ module LightGBM
       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)
+      safe_call FFI.LGBM_DatasetGetField(@handle, field_name, out_len, out_ptr, out_type)
       out_ptr.read_pointer.read_array_of_float(num_data)
     end
 
@@ -189,14 +213,12 @@ module LightGBM
       if type == :int32
         c_data = ::FFI::MemoryPointer.new(:int32, data.count)
         c_data.write_array_of_int32(data)
-        check_result FFI.LGBM_DatasetSetField(handle_pointer, field_name, c_data, data.count, 2)
+        safe_call FFI.LGBM_DatasetSetField(@handle, field_name, c_data, data.count, 2)
       else
         c_data = ::FFI::MemoryPointer.new(:float, data.count)
         c_data.write_array_of_float(data)
-        check_result FFI.LGBM_DatasetSetField(handle_pointer, field_name, c_data, data.count, 0)
+        safe_call FFI.LGBM_DatasetSetField(@handle, field_name, c_data, data.count, 0)
       end
     end
-
-    include Utils
   end
 end

data/lib/lightgbm/ffi.rb

@@ -15,6 +15,19 @@ module LightGBM
     # https://github.com/microsoft/LightGBM/blob/master/include/LightGBM/c_api.h
     # keep same order
 
+    C_API_DTYPE_FLOAT32 = 0
+    C_API_DTYPE_FLOAT64 = 1
+    C_API_DTYPE_INT32 = 2
+    C_API_DTYPE_INT64 = 3
+
+    C_API_PREDICT_NORMAL = 0
+    C_API_PREDICT_RAW_SCORE = 1
+    C_API_PREDICT_LEAF_INDEX = 2
+    C_API_PREDICT_CONTRIB = 3
+
+    C_API_FEATURE_IMPORTANCE_SPLIT = 0
+    C_API_FEATURE_IMPORTANCE_GAIN = 1
+
     # error
     attach_function :LGBM_GetLastError, %i[], :string
 
@@ -36,6 +49,7 @@ module LightGBM
     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_BoosterGetLoadedParam, %i[pointer int64 pointer pointer], :int
     attach_function :LGBM_BoosterFree, %i[pointer], :int
     attach_function :LGBM_BoosterAddValidData, %i[pointer pointer], :int
     attach_function :LGBM_BoosterGetNumClasses, %i[pointer pointer], :int
@@ -48,6 +62,7 @@ module LightGBM
     attach_function :LGBM_BoosterGetFeatureNames, %i[pointer int pointer size_t pointer pointer], :int
     attach_function :LGBM_BoosterGetNumFeature, %i[pointer pointer], :int
     attach_function :LGBM_BoosterGetEval, %i[pointer int pointer pointer], :int
+    attach_function :LGBM_BoosterCalcNumPredict, %i[pointer int int int int pointer], :int
     attach_function :LGBM_BoosterPredictForMat, %i[pointer pointer int int32 int32 int int int int string pointer pointer], :int
     attach_function :LGBM_BoosterSaveModel, %i[pointer int int int string], :int
     attach_function :LGBM_BoosterSaveModelToString, %i[pointer int int int int64 pointer pointer], :int

data/lib/lightgbm/inner_predictor.rb

@@ -0,0 +1,159 @@
+module LightGBM
+  class InnerPredictor
+    include Utils
+
+    MAX_INT32 = (1 << 31) - 1
+
+    def initialize(booster, pred_parameter)
+      @handle = booster.instance_variable_get(:@handle)
+      @pandas_categorical = booster.instance_variable_get(:@pandas_categorical)
+      @pred_parameter = params_str(pred_parameter)
+
+      # keep booster for cached_feature_name
+      @booster = booster
+    end
+
+    def self.from_booster(booster, pred_parameter)
+      new(booster, pred_parameter)
+    end
+
+    def predict(data, start_iteration: 0, num_iteration: -1, raw_score: false, pred_leaf: false, pred_contrib: false)
+      if data.is_a?(Dataset)
+        raise TypeError, "Cannot use Dataset instance for prediction, please use raw data instead"
+      end
+
+      predict_type = FFI::C_API_PREDICT_NORMAL
+      if raw_score
+        predict_type = FFI::C_API_PREDICT_RAW_SCORE
+      end
+      if pred_leaf
+        predict_type = FFI::C_API_PREDICT_LEAF_INDEX
+      end
+      if pred_contrib
+        predict_type = FFI::C_API_PREDICT_CONTRIB
+      end
+
+      if daru?(data)
+        data = data[*cached_feature_name].map_rows(&:to_a)
+        singular = false
+      elsif data.is_a?(Hash) # sort feature.values to match the order of model.feature_name
+        data = [sorted_feature_values(data)]
+        singular = true
+      elsif data.is_a?(Array) && data.first.is_a?(Hash) # on multiple elems, if 1st is hash, assume they all are
+        data = data.map(&method(:sorted_feature_values))
+        singular = false
+      elsif rover?(data)
+        # TODO improve performance
+        data = data[cached_feature_name].to_numo.to_a
+        singular = false
+      else
+        data = data.to_a
+        singular = !data.first.is_a?(Array)
+        data = [data] if singular
+        check_2d_array(data)
+        data = data.map(&:dup) if @pandas_categorical&.any?
+      end
+
+      if @pandas_categorical&.any?
+        apply_pandas_categorical(
+          data,
+          @booster.params["categorical_feature"],
+          @pandas_categorical
+        )
+      end
+
+      preds, nrow =
+        pred_for_array(
+          data,
+          start_iteration,
+          num_iteration,
+          predict_type
+        )
+
+      if pred_leaf
+        preds = preds.map(&:to_i)
+      end
+
+      if preds.size != nrow
+        if preds.size % nrow == 0
+          preds = preds.each_slice(preds.size / nrow).to_a
+        else
+          raise Error, "Length of predict result (#{preds.size}) cannot be divide nrow (#{nrow})"
+        end
+      end
+
+      singular ? preds.first : preds
+    end
+
+    private
+
+    def pred_for_array(input, start_iteration, num_iteration, predict_type)
+      nrow = input.count
+      if nrow > MAX_INT32
+        raise Error, "Not supported"
+      end
+      inner_predict_array(
+        input,
+        start_iteration,
+        num_iteration,
+        predict_type
+      )
+    end
+
+    def inner_predict_array(input, start_iteration, num_iteration, predict_type)
+      n_preds =
+        num_preds(
+          start_iteration,
+          num_iteration,
+          input.count,
+          predict_type
+        )
+
+      flat_input = input.flatten
+      handle_missing(flat_input)
+      data = ::FFI::MemoryPointer.new(:double, input.count * input.first.count)
+      data.write_array_of_double(flat_input)
+
+      out_num_preds = ::FFI::MemoryPointer.new(:int64)
+      out_result = ::FFI::MemoryPointer.new(:double, n_preds)
+      safe_call FFI.LGBM_BoosterPredictForMat(@handle, data, FFI::C_API_DTYPE_FLOAT64, input.count, input.first.count, 1, predict_type, start_iteration, num_iteration, @pred_parameter, out_num_preds, out_result)
+      if n_preds != out_num_preds.read_int64
+        raise Error, "Wrong length for predict results"
+      end
+      preds = out_result.read_array_of_double(out_num_preds.read_int64)
+      [preds, input.count]
+    end
+
+    def num_preds(start_iteration, num_iteration, nrow, predict_type)
+      out = ::FFI::MemoryPointer.new(:int64)
+      safe_call FFI.LGBM_BoosterCalcNumPredict(@handle, nrow, predict_type, start_iteration, num_iteration, out)
+      out.read_int64
+    end
+
+    def sorted_feature_values(input_hash)
+      input_hash.transform_keys(&:to_s).fetch_values(*cached_feature_name)
+    end
+
+    def cached_feature_name
+      @booster.send(:cached_feature_name)
+    end
+
+    def apply_pandas_categorical(data, categorical_feature, pandas_categorical)
+      (categorical_feature || []).each_with_index do |cf, i|
+        cat_codes = pandas_categorical[i].map.with_index.to_h
+        data.each do |r|
+          cat = r[cf]
+          unless cat.nil?
+            r[cf] =
+              cat_codes.fetch(cat) do
+                unless cat.is_a?(String)
+                  raise ArgumentError, "expected categorical value"
+                end
+                nil
+              end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lightgbm/model.rb

@@ -16,7 +16,7 @@ module LightGBM
     end
 
     def load_model(fname)
-      @booster = Booster.new(params: @params, model_file: fname)
+      @booster = Booster.new(model_file: fname)
     end
 
     def best_iteration

data/lib/lightgbm/utils.rb

@@ -2,8 +2,8 @@ module LightGBM
   module Utils
     private
 
-    def check_result(err)
-      raise LightGBM::Error, FFI.LGBM_GetLastError if err != 0
+    def safe_call(err)
+      raise Error, FFI.LGBM_GetLastError if err != 0
     end
 
     # remove spaces in keys and values to prevent injection
@@ -24,6 +24,13 @@ module LightGBM
       end
     end
 
+    def check_2d_array(data)
+      ncol = data.first&.size || 0
+      if !data.all? { |r| r.size == ncol }
+        raise ArgumentError, "Rows have different sizes"
+      end
+    end
+
     # for categorical, NaN and negative value are the same
     def handle_missing(data)
       data.map! { |v| v.nil? ? Float::NAN : v }

data/lib/lightgbm/version.rb

@@ -1,3 +1,3 @@
 module LightGBM
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

data/lib/lightgbm.rb

@@ -1,10 +1,14 @@
 # dependencies
 require "ffi"
 
+# stdlib
+require "json"
+
 # modules
 require_relative "lightgbm/utils"
 require_relative "lightgbm/booster"
 require_relative "lightgbm/dataset"
+require_relative "lightgbm/inner_predictor"
 require_relative "lightgbm/version"
 
 # scikit-learn API

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: lightgbm
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Andrew Kane
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-28 00:00:00.000000000 Z
+date: 2025-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -24,7 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
 email: andrew@ankane.org
 executables: []
 extensions: []
@@ -38,6 +36,7 @@ files:
 - lib/lightgbm/classifier.rb
 - lib/lightgbm/dataset.rb
 - lib/lightgbm/ffi.rb
+- lib/lightgbm/inner_predictor.rb
 - lib/lightgbm/model.rb
 - lib/lightgbm/ranker.rb
 - lib/lightgbm/regressor.rb
@@ -53,7 +52,6 @@ homepage: https://github.com/ankane/lightgbm-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -61,15 +59,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: High performance gradient boosting for Ruby
 test_files: []