easy_ml 0.1.4 → 0.2.0.pre.rc1

data/lib/easy_ml/core/tuner/adapters/xgboost_adapter.rb

@@ -5,44 +5,23 @@ module EasyML
     class Tuner
       module Adapters
         class XGBoostAdapter < BaseAdapter
-          include GlueGun::DSL
-
           def defaults
             {
               learning_rate: {
                 min: 0.001,
                 max: 0.1,
-                log: true
+                log: true,
               },
               n_estimators: {
                 min: 100,
-                max: 1_000
+                max: 1_000,
               },
               max_depth: {
                 min: 2,
-                max: 20
-              }
+                max: 20,
+              },
             }
           end
-
-          def configure_callbacks
-            model.customize_callbacks do |callbacks|
-              return unless callbacks.present?
-
-              wandb_callback = callbacks.detect { |cb| cb.class == Wandb::XGBoostCallback }
-              return unless wandb_callback.present?
-
-              wandb_callback.project_name = "#{wandb_callback.project_name}_#{tune_started_at.strftime("%Y_%m_%d_%H_%M_%S")}"
-              wandb_callback.custom_loggers = [
-                lambda do |booster, _epoch, _hist|
-                  dtrain = model.send(:preprocess, x_true, y_true)
-                  y_pred = booster.predict(dtrain)
-                  metrics = model.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true)
-                  Wandb.log(metrics)
-                end
-              ]
-            end
-          end
         end
       end
     end

data/lib/easy_ml/core/tuner.rb

@@ -4,34 +4,36 @@ require_relative "tuner/adapters"
 module EasyML
   module Core
     class Tuner
-      include GlueGun::DSL
-
-      attribute :model
-      attribute :dataset
-      attribute :project_name, :string
-      attribute :task, :string
-      attribute :config, :hash, default: {}
-      attribute :metrics, :array
-      attribute :objective, :string
-      attribute :n_trials, default: 100
-      attribute :callbacks, :array
-      attr_accessor :study, :results
-
-      dependency :adapter, lazy: false do |dep|
-        dep.option :xgboost do |opt|
-          opt.set_class Adapters::XGBoostAdapter
-          opt.bind_attribute :model
-          opt.bind_attribute :config
-          opt.bind_attribute :project_name
-          opt.bind_attribute :tune_started_at
-          opt.bind_attribute :y_true
-        end
+      attr_accessor :model, :dataset, :project_name, :task, :config,
+                    :metrics, :objective, :n_trials, :direction, :evaluator,
+                    :study, :results, :adapter, :tune_started_at, :x_true, :y_true,
+                    :project_name, :job, :current_run
+
+      def initialize(options = {})
+        @model = options[:model]
+        @dataset = options[:dataset]
+        @project_name = options[:project_name]
+        @task = options[:task]
+        @config = options[:config] || {}
+        @metrics = options[:metrics]
+        @objective = options[:objective]
+        @n_trials = options[:n_trials] || 100
+        @direction = EasyML::Core::ModelEvaluator.get(objective).new.direction
+        @evaluator = options[:evaluator]
+        @tune_started_at = EasyML::Support::UTC.now
+        @project_name = "#{@model.name}_#{tune_started_at.strftime("%Y_%m_%d_%H_%M_%S")}"
+      end
 
-        dep.when do |_dep|
-          case model
-          when EasyML::Core::Models::XGBoost, EasyML::Models::XGBoost
-            { option: :xgboost }
-          end
+      def initialize_adapter
+        case model&.model_type
+        when "xgboost"
+          Adapters::XGBoostAdapter.new(
+            model: model,
+            config: config,
+            project_name: project_name,
+            tune_started_at: nil,  # This will be set during tune
+            y_true: nil, # This will be set during tune
+          )
         end
       end
 
@@ -41,53 +43,112 @@ module EasyML
         raise "Trial failed: Stopping optimization."
       end
 
-      def tune
-        set_defaults!
+      def wandb_enabled?
+        EasyML::Configuration.wandb_api_key.present?
+      end
 
-        @study = Optuna::Study.new
+      def tune(&progress_block)
+        set_defaults!
+        @adapter = initialize_adapter
+
+        tuner_params = {
+          model: model,
+          config: {
+            n_trials: n_trials,
+            objective: objective,
+            hyperparameter_ranges: config,
+          },
+          direction: direction,
+          status: :running,
+          started_at: Time.current,
+          wandb_url: wandb_enabled? ? "https://wandb.ai/fundera/#{@project_name}" : nil,
+        }.compact
+
+        tuner_job = EasyML::TunerJob.create!(tuner_params)
+        @job = tuner_job
+        @study = Optuna::Study.new(direction: direction)
         @results = []
+        model.evaluator = evaluator if evaluator.present?
         model.task = task
+
+        model.dataset.refresh
         x_true, y_true = model.dataset.test(split_ys: true)
-        tune_started_at = EST.now
-        adapter = pick_adapter.new(model: model, config: config, tune_started_at: tune_started_at, y_true: y_true,
-                                   x_true: x_true)
-        adapter.configure_callbacks
-
-        @study.optimize(n_trials: n_trials, callbacks: [method(:loggers)]) do |trial|
-          run_metrics = tune_once(trial, x_true, y_true, adapter)
-
-          result = if model.evaluator.present?
-                     if model.evaluator_metric.present?
-                       run_metrics[model.evaluator_metric]
-                     else
-                       run_metrics[:custom]
-                     end
-                   else
-                     run_metrics[objective.to_sym]
-                   end
-          @results.push(result)
-          result
-        rescue StandardError => e
-          puts "Optuna failed with: #{e.message}"
+        self.x_true = x_true
+        self.y_true = y_true
+        adapter.tune_started_at = tune_started_at
+        adapter.y_true = y_true
+        adapter.x_true = x_true
+
+        model.prepare_data unless model.batch_mode
+        model.prepare_callbacks(self)
+
+        n_trials.times do |run_number|
+          trial = @study.ask
+          puts "Running trial #{trial.number}"
+          @tuner_run = tuner_job.tuner_runs.new(
+            trial_number: trial.number,
+            status: :running,
+          )
+
+          self.current_run = @tuner_run
+
+          begin
+            run_metrics = tune_once(trial, x_true, y_true, adapter, &progress_block)
+            result = calculate_result(run_metrics)
+            @results.push(result)
+
+            params = {
+              hyperparameters: model.hyperparameters.to_h,
+              value: result,
+              status: :success,
+            }.compact
+
+            @tuner_run.update!(params)
+            @study.tell(trial, result)
+          rescue StandardError => e
+            @tuner_run.update!(status: :failed, hyperparameters: {})
+            puts "Optuna failed with: #{e.message}"
+            raise e
+          end
         end
 
-        raise "Optuna study failed" unless @study.respond_to?(:best_trial)
-
-        @study.best_trial.params
+        model.after_tuning
+        return nil if tuner_job.tuner_runs.all?(&:failed?)
+
+        best_run = tuner_job.best_run
+        tuner_job.update!(
+          metadata: adapter.metadata,
+          best_tuner_run_id: best_run&.id,
+          status: :success,
+          completed_at: Time.current,
+        )
+
+        best_run&.hyperparameters
+      rescue StandardError => e
+        tuner_job&.update!(status: :failed, completed_at: Time.current)
+        raise e
       end
 
-      def pick_adapter
-        case model
-        when EasyML::Core::Models::XGBoost, EasyML::Models::XGBoost
-          Adapters::XGBoostAdapter
+      private
+
+      def calculate_result(run_metrics)
+        run_metrics.symbolize_keys!
+
+        if model.evaluator.present?
+          run_metrics[model.evaluator[:metric].to_sym]
+        else
+          run_metrics[objective.to_sym]
         end
       end
 
-      def tune_once(trial, x_true, y_true, adapter)
+      def tune_once(trial, x_true, y_true, adapter, &progress_block)
         adapter.run_trial(trial) do |model|
-          y_pred = model.predict(y_true)
+          model.fit(tuning: true, &progress_block)
+          y_pred = model.predict(x_true)
           model.metrics = metrics
-          model.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true)
+          metrics = model.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true)
+          puts metrics
+          metrics
         end
       end
 
@@ -98,7 +159,7 @@ module EasyML
         end
         raise ArgumentError, "Objectives required for EasyML::Core::Tuner" unless objective.present?
 
-        self.metrics = EasyML::Core::Model.new(task: task).allowed_metrics if metrics.nil? || metrics.empty?
+        self.metrics = EasyML::Model.new(task: task).allowed_metrics if metrics.nil? || metrics.empty?
       end
     end
   end

data/lib/easy_ml/core.rb

@@ -1,8 +1,5 @@
 module EasyML
   module Core
-    require_relative "core/uploaders"
-    require_relative "core/model"
-    require_relative "core/models"
     require_relative "core/model_evaluator"
     require_relative "core/tuner"
   end

data/lib/easy_ml/core_ext/hash.rb

@@ -0,0 +1,24 @@
+module EasyML
+  module CoreExt
+    module Hash
+      def deep_compact
+        each_with_object({}) do |(key, value), result|
+          next if value.nil?
+
+          compacted = if value.is_a?(Hash)
+              value.deep_compact
+            elsif value.is_a?(Array)
+              value.map { |v| v.is_a?(Hash) ? v.deep_compact : v }.compact
+            else
+              value
+            end
+
+          result[key] = compacted unless compacted.blank?
+        end
+      end
+    end
+  end
+end
+
+# Extend Hash class with our custom method
+Hash.include EasyML::CoreExt::Hash

data/lib/easy_ml/core_ext/pathname.rb

@@ -1,9 +1,15 @@
 require "pathname"
 
-class Pathname
-  def append(folder)
-    dir = cleanpath
-    dir = dir.join(folder) unless basename.to_s == folder
-    dir
+module EasyML
+  module CoreExt
+    module Pathname
+      def append(folder)
+        dir = cleanpath
+        dir = dir.join(folder) unless basename.to_s == folder
+        dir
+      end
+    end
   end
 end
+
+Pathname.include EasyML::CoreExt::Pathname

data/lib/easy_ml/data/date_converter.rb

@@ -0,0 +1,90 @@
+module EasyML
+  module Data
+    module DateConverter
+      COMMON_DATE_FORMATS = [
+        "%Y-%m-%dT%H:%M:%S.%6N",   # e.g., "2021-01-01T00:00:00.000000"
+        "%Y-%m-%d %H:%M:%S.%L",    # e.g., "2021-01-01 00:01:36.000"
+        "%Y-%m-%d %H:%M:%S.%L",   # e.g., "2021-01-01 00:01:36.000"
+        "%Y-%m-%d %H:%M:%S",      # e.g., "2021-01-01 00:01:36"
+        "%Y-%m-%d %H:%M",         # e.g., "2021-01-01 00:01"
+        "%Y-%m-%d",               # e.g., "2021-01-01"
+        "%m/%d/%Y %H:%M:%S",      # e.g., "01/01/2021 00:01:36"
+        "%m/%d/%Y",               # e.g., "01/01/2021"
+        "%d-%m-%Y",               # e.g., "01-01-2021"
+        "%d-%b-%Y %H:%M:%S",      # e.g., "01-Jan-2021 00:01:36"
+        "%d-%b-%Y",               # e.g., "01-Jan-2021"
+        "%b %d, %Y",              # e.g., "Jan 01, 2021"
+        "%Y/%m/%d %H:%M:%S",      # e.g., "2021/01/01 00:01:36"
+        "%Y/%m/%d",                # e.g., "2021/01/01"
+      ].freeze
+
+      FORMAT_MAPPINGS = {
+        ruby_to_polars: {
+          "%L" => "%3f",  # milliseconds
+          "%6N" => "%6f", # microseconds
+          "%N" => "%9f", # nanoseconds
+        },
+      }.freeze
+
+      class << self
+        # Attempts to convert a string column to datetime if it appears to be a date
+        # @param df [Polars::DataFrame] The dataframe containing the series
+        # @param column [String] The name of the column to convert
+        # @return [Polars::DataFrame] The dataframe with converted column (if successful)
+        def maybe_convert_date(df, column = nil)
+          if column.nil?
+            series = df
+            column = series.name
+            df = Polars::DataFrame.new(series)
+          else
+            series = df[column]
+          end
+          return df if series.dtype.is_a?(Polars::Datetime)
+          return df unless series.dtype == Polars::Utf8
+
+          format = detect_polars_format(series)
+          return df unless format
+
+          df.with_column(
+            Polars.col(column.to_s).str.strptime(Polars::Datetime, format).alias(column.to_s)
+          )
+        end
+
+        private
+
+        def detect_polars_format(series)
+          return nil unless series.is_a?(Polars::Series)
+
+          sample = series.filter(series.is_not_null).head(100).to_a
+          ruby_format = detect_date_format(sample)
+          convert_format(:ruby_to_polars, ruby_format)
+        end
+
+        def detect_date_format(date_strings)
+          return nil if date_strings.empty?
+
+          sample = date_strings.compact.sample([100, date_strings.length].min)
+
+          COMMON_DATE_FORMATS.detect do |format|
+            sample.all? do |date_str|
+              DateTime.strptime(date_str, format)
+              true
+            rescue StandardError
+              false
+            end
+          end
+        end
+
+        def convert_format(conversion, format)
+          return nil if format.nil?
+
+          result = format.dup
+          FORMAT_MAPPINGS[conversion].each do |from, to|
+            result = result.gsub(from, to)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/easy_ml/data/filter_extensions.rb

@@ -0,0 +1,31 @@
+module EasyML
+  module Data
+    module FilterExtensions
+      def is_primary_key_filter?(primary_key)
+        return false unless primary_key
+        primary_key = [primary_key] unless primary_key.is_a?(Array)
+        # Filter expressions in Polars are represented as strings like:
+        # [([(col("LOAN_APP_ID")) > (dyn int: 4)]) & ([(col("LOAN_APP_ID")) < (dyn int: 16)])]
+        expr_str = to_s
+        return false unless expr_str.include?(primary_key.first)
+
+        # Check for common primary key operations
+        primary_key_ops = [">", "<", ">=", "<=", "=", "eq", "gt", "lt", "ge", "le"]
+        primary_key_ops.any? { |op| expr_str.include?(op) }
+      end
+
+      def extract_primary_key_values
+        expr_str = to_s
+        # Extract numeric values from the expression
+        # This will match both integers and floats
+        values = expr_str.scan(/(?:dyn int|float): (-?\d+(?:\.\d+)?)/).flatten.map(&:to_f)
+        values.uniq
+      end
+    end
+  end
+end
+
+# Extend Polars classes with our filter functionality
+[Polars::Expr].each do |klass|
+  klass.include(EasyML::Data::FilterExtensions)
+end

data/lib/easy_ml/data/polars_column.rb

@@ -0,0 +1,126 @@
+require_relative "date_converter"
+
+module EasyML
+  module Data
+    module PolarsColumn
+      TYPE_MAP = {
+        float: Polars::Float64,
+        integer: Polars::Int64,
+        boolean: Polars::Boolean,
+        datetime: Polars::Datetime,
+        string: Polars::String,
+        text: Polars::String,
+        categorical: Polars::Categorical
+      }
+      POLARS_MAP = TYPE_MAP.invert.stringify_keys
+      class << self
+        def polars_to_sym(polars_type)
+          POLARS_MAP.dig(polars_type.class.to_s)
+        end
+
+        def sym_to_polars(symbol)
+          TYPE_MAP.dig(symbol)
+        end
+
+        # Determines the semantic type of a field based on its data
+        # @param series [Polars::Series] The series to analyze
+        # @return [Symbol] One of :numeric, :datetime, :categorical, or :text
+        def determine_type(series, polars_type = false)
+          dtype = series.dtype
+
+          if dtype.is_a?(Polars::Utf8)
+            string_type = determine_string_type(series)
+            if string_type == :datetime
+              date = EasyML::Data::DateConverter.maybe_convert_date(series)
+              return polars_type ? date[date.columns.first].dtype : :datetime
+            end
+          end
+
+          type_name = case dtype
+                      when Polars::Float64
+                        :float
+                      when Polars::Int64
+                        :integer
+                      when Polars::Datetime
+                        :datetime
+                      when Polars::Boolean
+                        :boolean
+                      when Polars::Utf8
+                        determine_string_type(series)
+                      else
+                        :categorical
+                      end
+
+          polars_type ? sym_to_polars(type_name) : type_name
+        end
+
+        # Determines if a string field is a date, text, or categorical
+        # @param series [Polars::Series] The string series to analyze
+        # @return [Symbol] One of :datetime, :text, or :categorical
+        def determine_string_type(series)
+          if EasyML::Data::DateConverter.maybe_convert_date(Polars::DataFrame.new({ temp: series }),
+                                                            :temp)[:temp].dtype.is_a?(Polars::Datetime)
+            :datetime
+          else
+            categorical_or_text?(series)
+          end
+        end
+
+        # Determines if a string field is categorical or free text
+        # @param series [Polars::Series] The string series to analyze
+        # @return [Symbol] Either :categorical or :text
+        def categorical_or_text?(series)
+          return :categorical if series.null_count == series.len
+
+          # Get non-null count for percentage calculations
+          non_null_count = series.len - series.null_count
+          return :categorical if non_null_count == 0
+
+          # Get value counts as percentages
+          value_counts = series.value_counts(parallel: true)
+          percentages = value_counts.with_column(
+            (value_counts["count"] / non_null_count.to_f * 100).alias("percentage")
+          )
+
+          # Check if any category represents more than 10% of the data
+          max_percentage = percentages["percentage"].max
+          return :text if max_percentage < 10.0
+
+          # Calculate average percentage per category
+          avg_percentage = 100.0 / series.n_unique
+
+          # If average category represents less than 1% of data, it's likely text
+          avg_percentage < 1.0 ? :text : :categorical
+        end
+
+        # Returns whether the field type is numeric
+        # @param field_type [Symbol] The field type to check
+        # @return [Boolean]
+        def numeric?(field_type)
+          field_type == :numeric
+        end
+
+        # Returns whether the field type is categorical
+        # @param field_type [Symbol] The field type to check
+        # @return [Boolean]
+        def categorical?(field_type)
+          field_type == :categorical
+        end
+
+        # Returns whether the field type is datetime
+        # @param field_type [Symbol] The field type to check
+        # @return [Boolean]
+        def datetime?(field_type)
+          field_type == :datetime
+        end
+
+        # Returns whether the field type is text
+        # @param field_type [Symbol] The field type to check
+        # @return [Boolean]
+        def text?(field_type)
+          field_type == :text
+        end
+      end
+    end
+  end
+end