easy_ml 0.1.4 → 0.2.0.pre.rc1

data/lib/easy_ml/core/model_core.rb

@@ -1,181 +0,0 @@
-require "carrierwave"
-require_relative "uploaders/model_uploader"
-
-module EasyML
-  module Core
-    module ModelCore
-      attr_accessor :dataset
-
-      def self.included(base)
-        base.send(:include, GlueGun::DSL)
-        base.send(:extend, CarrierWave::Mount)
-        base.send(:mount_uploader, :file, EasyML::Core::Uploaders::ModelUploader)
-
-        base.class_eval do
-          validates :task, inclusion: { in: %w[regression classification] }
-          validates :task, presence: true
-          validate :dataset_is_a_dataset?
-          validate :validate_any_metrics?
-          validate :validate_metrics_for_task
-          before_validation :save_model_file, if: -> { fit? }
-        end
-      end
-
-      def fit(x_train: nil, y_train: nil, x_valid: nil, y_valid: nil)
-        if x_train.nil?
-          dataset.refresh!
-          train_in_batches
-        else
-          train(x_train, y_train, x_valid, y_valid)
-        end
-        @is_fit = true
-      end
-
-      def predict(xs)
-        raise NotImplementedError, "Subclasses must implement predict method"
-      end
-
-      def load
-        raise NotImplementedError, "Subclasses must implement load method"
-      end
-
-      def _save_model_file
-        raise NotImplementedError, "Subclasses must implement _save_model_file method"
-      end
-
-      def save
-        super if defined?(super) && self.class.superclass.method_defined?(:save)
-        save_model_file
-      end
-
-      def decode_labels(ys, col: nil)
-        dataset.decode_labels(ys, col: col)
-      end
-
-      def evaluate(y_pred: nil, y_true: nil, x_true: nil, evaluator: nil)
-        evaluator ||= self.evaluator
-        EasyML::Core::ModelEvaluator.evaluate(model: self, y_pred: y_pred, y_true: y_true, x_true: x_true,
-                                              evaluator: evaluator)
-      end
-
-      def save_model_file
-        raise "No trained model! Need to train model before saving (call model.fit)" unless fit?
-
-        path = File.join(model_dir, "#{version}.json")
-        ensure_directory_exists(File.dirname(path))
-
-        _save_model_file(path)
-
-        File.open(path) do |f|
-          self.file = f
-        end
-        file.store!
-
-        cleanup
-      end
-
-      def get_params
-        @hyperparameters.to_h
-      end
-
-      def allowed_metrics
-        return [] unless task.present?
-
-        case task.to_sym
-        when :regression
-          %w[mean_absolute_error mean_squared_error root_mean_squared_error r2_score]
-        when :classification
-          %w[accuracy_score precision_score recall_score f1_score auc roc_auc]
-        else
-          []
-        end
-      end
-
-      def cleanup!
-        [carrierwave_dir, model_dir].each do |dir|
-          EasyML::FileRotate.new(dir, []).cleanup(extension_allowlist)
-        end
-      end
-
-      def cleanup
-        [carrierwave_dir, model_dir].each do |dir|
-          EasyML::FileRotate.new(dir, files_to_keep).cleanup(extension_allowlist)
-        end
-      end
-
-      def fit?
-        @is_fit == true
-      end
-
-      private
-
-      def carrierwave_dir
-        return unless file.path.present?
-
-        File.dirname(file.path).split("/")[0..-2].join("/")
-      end
-
-      def extension_allowlist
-        EasyML::Core::Uploaders::ModelUploader.new.extension_allowlist
-      end
-
-      def _save_model_file(path = nil)
-        raise NotImplementedError, "Subclasses must implement _save_model_file method"
-      end
-
-      def ensure_directory_exists(dir)
-        FileUtils.mkdir_p(dir) unless File.directory?(dir)
-      end
-
-      def apply_defaults
-        self.version ||= generate_version_string
-        self.metrics ||= allowed_metrics
-        self.ml_model ||= get_ml_model
-      end
-
-      def get_ml_model
-        self.class.name.split("::").last.underscore
-      end
-
-      def generate_version_string
-        timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
-        model_name = self.class.name.split("::").last.underscore
-        "#{model_name}_#{timestamp}"
-      end
-
-      def model_dir
-        File.join(root_dir, "easy_ml_models", name.present? ? name.split.join.underscore : "")
-      end
-
-      def files_to_keep
-        Dir.glob(File.join(carrierwave_dir, "**/*")).select { |f| File.file?(f) }.sort_by do |filename|
-          Time.parse(filename.split("/").last.gsub(/\D/, ""))
-        end.reverse.take(5)
-      end
-
-      def dataset_is_a_dataset?
-        return if dataset.nil?
-        return if dataset.class.ancestors.include?(EasyML::Data::Dataset)
-
-        errors.add(:dataset, "Must be a subclass of EasyML::Dataset")
-      end
-
-      def validate_any_metrics?
-        return if metrics.any?
-
-        errors.add(:metrics, "Must include at least one metric. Allowed metrics are #{allowed_metrics.join(", ")}")
-      end
-
-      def validate_metrics_for_task
-        nonsensical_metrics = metrics.select do |metric|
-          allowed_metrics.exclude?(metric)
-        end
-
-        return unless nonsensical_metrics.any?
-
-        errors.add(:metrics,
-                   "cannot use metrics: #{nonsensical_metrics.join(", ")} for task #{task}. Allowed metrics are: #{allowed_metrics.join(", ")}")
-      end
-    end
-  end
-end

data/lib/easy_ml/core/models/hyperparameters/base.rb

@@ -1,34 +0,0 @@
-module EasyML
-  module Models
-    module Hyperparameters
-      class Base
-        include GlueGun::DSL
-
-        attribute :learning_rate, :float, default: 0.01
-        attribute :max_iterations, :integer, default: 100
-        attribute :batch_size, :integer, default: 32
-        attribute :regularization, :float, default: 0.0001
-
-        def to_h
-          attributes
-        end
-
-        def merge(other)
-          return self if other.nil?
-
-          other_hash = other.is_a?(Hyperparameters) ? other.to_h : other
-          merged_hash = to_h.merge(other_hash)
-          self.class.new(**merged_hash)
-        end
-
-        def [](key)
-          send(key) if respond_to?(key)
-        end
-
-        def []=(key, value)
-          send("#{key}=", value) if respond_to?("#{key}=")
-        end
-      end
-    end
-  end
-end

data/lib/easy_ml/core/models/hyperparameters/xgboost.rb

@@ -1,19 +0,0 @@
-module EasyML
-  module Models
-    module Hyperparameters
-      class XGBoost < Base
-        include GlueGun::DSL
-
-        attribute :learning_rate, :float, default: 0.1
-        attribute :max_depth, :integer, default: 6
-        attribute :n_estimators, :integer, default: 100
-        attribute :booster, :string, default: "gbtree"
-        attribute :objective, :string, default: "reg:squarederror"
-
-        validates :objective,
-                  inclusion: { in: %w[binary:logistic binary:hinge multi:softmax multi:softprob reg:squarederror
-                                      reg:logistic] }
-      end
-    end
-  end
-end

data/lib/easy_ml/core/models/xgboost.rb

@@ -1,10 +0,0 @@
-require_relative "xgboost_core"
-module EasyML
-  module Core
-    module Models
-      class XGBoost < EasyML::Core::Model
-        include XGBoostCore
-      end
-    end
-  end
-end

data/lib/easy_ml/core/models/xgboost_core.rb

@@ -1,220 +0,0 @@
-require "wandb"
-module EasyML
-  module Core
-    module Models
-      module XGBoostCore
-        OBJECTIVES = {
-          classification: {
-            binary: %w[binary:logistic binary:hinge],
-            multi_class: %w[multi:softmax multi:softprob]
-          },
-          regression: %w[reg:squarederror reg:logistic]
-        }
-
-        def self.included(base)
-          base.class_eval do
-            attribute :evaluator
-
-            dependency :callbacks, { array: true } do |dep|
-              dep.option :wandb do |opt|
-                opt.set_class Wandb::XGBoostCallback
-                opt.bind_attribute :log_model, default: false
-                opt.bind_attribute :log_feature_importance, default: true
-                opt.bind_attribute :importance_type, default: "gain"
-                opt.bind_attribute :define_metric, default: true
-                opt.bind_attribute :project_name
-              end
-            end
-
-            dependency :hyperparameters do |dep|
-              dep.set_class EasyML::Models::Hyperparameters::XGBoost
-              dep.bind_attribute :batch_size, default: 32
-              dep.bind_attribute :learning_rate, default: 1.1
-              dep.bind_attribute :max_depth, default: 6
-              dep.bind_attribute :n_estimators, default: 100
-              dep.bind_attribute :booster, default: "gbtree"
-              dep.bind_attribute :objective, default: "reg:squarederror"
-            end
-          end
-        end
-
-        attr_accessor :model, :booster
-
-        def predict(xs)
-          raise "No trained model! Train a model before calling predict" unless @booster.present?
-          raise "Cannot predict on nil — XGBoost" if xs.nil?
-
-          y_pred = @booster.predict(preprocess(xs))
-
-          case task.to_sym
-          when :classification
-            to_classification(y_pred)
-          else
-            y_pred
-          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 load(path = nil)
-          path ||= file
-          path = path&.file&.file if path.class.ancestors.include?(CarrierWave::Uploader::Base)
-
-          raise "No existing model at #{path}" unless File.exist?(path)
-
-          initialize_model do
-            booster_class.new(params: hyperparameters.to_h, model_file: path)
-          end
-        end
-
-        def _save_model_file(path)
-          puts "XGBoost received path #{path}"
-          @booster.save_model(path)
-        end
-
-        def feature_importances
-          @model.booster.feature_names.zip(@model.feature_importances).to_h
-        end
-
-        def base_model
-          ::XGBoost
-        end
-
-        def customize_callbacks
-          yield callbacks
-        end
-
-        private
-
-        def booster_class
-          ::XGBoost::Booster
-        end
-
-        def d_matrix_class
-          ::XGBoost::DMatrix
-        end
-
-        def model_class
-          ::XGBoost::Model
-        end
-
-        def train
-          validate_objective
-
-          xs = xs.to_a.map(&:values)
-          ys = ys.to_a.map(&:values)
-          dtrain = d_matrix_class.new(xs, label: ys)
-          @model = base_model.train(hyperparameters.to_h, dtrain, callbacks: callbacks)
-        end
-
-        def train_in_batches
-          validate_objective
-
-          # Initialize the model with the first batch
-          @model = nil
-          @booster = nil
-          x_valid, y_valid = dataset.valid(split_ys: true)
-          x_train, y_train = dataset.train(split_ys: true)
-          fit_batch(x_train, y_train, x_valid, y_valid)
-        end
-
-        def _preprocess(df)
-          df.to_a.map do |row|
-            row.values.map do |value|
-              case value
-              when Time
-                value.to_i # Convert Time to Unix timestamp
-              when Date
-                value.to_time.to_i # Convert Date to Unix timestamp
-              when String
-                value
-              when TrueClass, FalseClass
-                value ? 1.0 : 0.0 # Convert booleans to 1.0 and 0.0
-              when Integer
-                value
-              else
-                value.to_f # Ensure everything else is converted to a float
-              end
-            end
-          end
-        end
-
-        def preprocess(xs, ys = nil)
-          column_names = xs.columns
-          xs = _preprocess(xs)
-          ys = ys.nil? ? nil : _preprocess(ys).flatten
-          kwargs = { label: ys }.compact
-          ::XGBoost::DMatrix.new(xs, **kwargs).tap do |dmat|
-            dmat.feature_names = column_names
-          end
-        end
-
-        def initialize_model
-          @model = model_class.new(n_estimators: @hyperparameters.to_h.dig(:n_estimators))
-          @booster = yield
-          @model.instance_variable_set(:@booster, @booster)
-        end
-
-        def validate_objective
-          objective = hyperparameters.objective
-          unless task.present?
-            raise ArgumentError,
-                  "cannot train model without task. Please specify either regression or classification (model.task = :regression)"
-          end
-
-          case task.to_sym
-          when :classification
-            _, ys = dataset.data(split_ys: true)
-            classification_type = ys[ys.columns.first].uniq.count <= 2 ? :binary : :multi_class
-            allowed_objectives = OBJECTIVES[:classification][classification_type]
-          else
-            allowed_objectives = OBJECTIVES[task.to_sym]
-          end
-          return if allowed_objectives.map(&:to_sym).include?(objective.to_sym)
-
-          raise ArgumentError,
-                "cannot use #{objective} for #{task} task. Allowed objectives are: #{allowed_objectives.join(", ")}"
-        end
-
-        def fit_batch(x_train, y_train, x_valid, y_valid)
-          d_train = preprocess(x_train, y_train)
-          d_valid = preprocess(x_valid, y_valid)
-
-          evals = [[d_train, "train"], [d_valid, "eval"]]
-
-          # # If this is the first batch, create the booster
-          if @booster.nil?
-            initialize_model do
-              base_model.train(@hyperparameters.to_h, d_train,
-                               num_boost_round: @hyperparameters.to_h.dig("n_estimators"), evals: evals, callbacks: callbacks)
-            end
-          else
-            # Update the existing booster with the new batch
-            @model.update(d_train)
-          end
-        end
-
-        def to_classification(y_pred)
-          if y_pred.first.is_a?(Array)
-            # multiple classes
-            y_pred.map do |v|
-              v.map.with_index.max_by { |v2, _| v2 }.last
-            end
-          else
-            y_pred.map { |v| v > 0.5 ? 1 : 0 }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/easy_ml/core/models.rb

@@ -1,10 +0,0 @@
-module EasyML
-  module Core
-    module Models
-      require_relative "models/hyperparameters"
-      require_relative "models/xgboost"
-
-      AVAILABLE_MODELS = [XGBoost]
-    end
-  end
-end

data/lib/easy_ml/core/uploaders/model_uploader.rb

@@ -1,24 +0,0 @@
-require "carrierwave"
-
-module EasyML
-  module Core
-    module Uploaders
-      class ModelUploader < CarrierWave::Uploader::Base
-        # Choose storage type
-        if Rails.env.production?
-          storage :fog
-        else
-          storage :file
-        end
-
-        def store_dir
-          "easy_ml_models/#{model.name}"
-        end
-
-        def extension_allowlist
-          %w[bin model json]
-        end
-      end
-    end
-  end
-end

data/lib/easy_ml/core/uploaders.rb

@@ -1,7 +0,0 @@
-module EasyML
-  module Core
-    module Uploaders
-      require_relative "uploaders/model_uploader"
-    end
-  end
-end

data/lib/easy_ml/data/dataloader.rb

@@ -1,6 +0,0 @@
-module ML
-  module Data
-    class Dataloader
-    end
-  end
-end

data/lib/easy_ml/data/dataset/data/preprocessor/statistics.json

@@ -1,31 +0,0 @@
-{
-  "annual_revenue": {
-    "median": {
-      "value": 3000.0,
-      "original_dtype": {
-        "__type__": "polars_dtype",
-        "value": "Polars::Int64"
-      }
-    }
-  },
-  "loan_purpose": {
-    "categorical": {
-      "value": {
-        "payroll": 4,
-        "expansion": 1
-      },
-      "label_encoder": {
-        "expansion": 0,
-        "payroll": 1
-      },
-      "label_decoder": {
-        "0": "expansion",
-        "1": "payroll"
-      },
-      "original_dtype": {
-        "__type__": "polars_dtype",
-        "value": "Polars::String"
-      }
-    }
-  }
-}

data/lib/easy_ml/data/dataset/data/sample_info.json

@@ -1 +0,0 @@
-{"previous_sample":1.0}

data/lib/easy_ml/data/dataset/dataset/files/sample_info.json

@@ -1 +0,0 @@
-{"previous_sample":1.0}

data/lib/easy_ml/data/dataset/splits/file_split.rb

@@ -1,140 +0,0 @@
-require_relative "split"
-
-module EasyML
-  module Data
-    class Dataset
-      module Splits
-        class FileSplit < Split
-          include GlueGun::DSL
-          include EasyML::Data::Utils
-
-          attribute :dir, :string
-          attribute :polars_args, :hash, default: {}
-          attribute :max_rows_per_file, :integer, default: 1_000_000
-          attribute :batch_size, :integer, default: 10_000
-          attribute :sample, :float, default: 1.0
-          attribute :verbose, :boolean, default: false
-
-          def initialize(options)
-            super
-            FileUtils.mkdir_p(dir)
-          end
-
-          def save(segment, df)
-            segment_dir = File.join(dir, segment.to_s)
-            FileUtils.mkdir_p(segment_dir)
-
-            current_file = current_file_for_segment(segment)
-            current_row_count = current_file && File.exist?(current_file) ? df(current_file).shape[0] : 0
-            remaining_rows = max_rows_per_file - current_row_count
-
-            while df.shape[0] > 0
-              if df.shape[0] <= remaining_rows
-                append_to_csv(df, current_file)
-                break
-              else
-                df_to_append = df.slice(0, remaining_rows)
-                df = df.slice(remaining_rows, df.shape[0] - remaining_rows)
-                append_to_csv(df_to_append, current_file)
-                current_file = new_file_path_for_segment(segment)
-                remaining_rows = max_rows_per_file
-              end
-            end
-          end
-
-          def read(segment, split_ys: false, target: nil, drop_cols: [], &block)
-            files = files_for_segment(segment)
-
-            if block_given?
-              result = nil
-              total_rows = files.sum { |file| df(file).shape[0] }
-              progress_bar = create_progress_bar(segment, total_rows) if verbose
-
-              files.each do |file|
-                df = self.df(file)
-                df = sample_data(df) if sample < 1.0
-                drop_cols &= df.columns
-                df = df.drop(drop_cols) unless drop_cols.empty?
-
-                if split_ys
-                  xs, ys = split_features_targets(df, true, target)
-                  result = process_block_with_split_ys(block, result, xs, ys)
-                else
-                  result = process_block_without_split_ys(block, result, df)
-                end
-
-                progress_bar.progress += df.shape[0] if verbose
-              end
-              progress_bar.finish if verbose
-              result
-            elsif files.empty?
-              return nil, nil if split_ys
-
-              nil
-
-            else
-              combined_df = combine_dataframes(files)
-              combined_df = sample_data(combined_df) if sample < 1.0
-              drop_cols &= combined_df.columns
-              combined_df = combined_df.drop(drop_cols) unless drop_cols.empty?
-              split_features_targets(combined_df, split_ys, target)
-            end
-          end
-
-          def cleanup
-            FileUtils.rm_rf(dir)
-            FileUtils.mkdir_p(dir)
-          end
-
-          def split_at
-            return nil if output_files.empty?
-
-            output_files.map { |file| File.mtime(file) }.max
-          end
-
-          private
-
-          def read_csv_batched(path)
-            Polars.read_csv_batched(path, batch_size: batch_size, **polars_args)
-          end
-
-          def df(path)
-            Polars.read_csv(path, **polars_args)
-          end
-
-          def output_files
-            Dir.glob("#{dir}/**/*.csv")
-          end
-
-          def files_for_segment(segment)
-            segment_dir = File.join(dir, segment.to_s)
-            Dir.glob(File.join(segment_dir, "**/*.csv")).sort
-          end
-
-          def current_file_for_segment(segment)
-            current_file = files_for_segment(segment).last
-            return new_file_path_for_segment(segment) if current_file.nil?
-
-            row_count = df(current_file).shape[0]
-            if row_count >= max_rows_per_file
-              new_file_path_for_segment(segment)
-            else
-              current_file
-            end
-          end
-
-          def new_file_path_for_segment(segment)
-            segment_dir = File.join(dir, segment.to_s)
-            file_number = Dir.glob(File.join(segment_dir, "*.csv")).count
-            File.join(segment_dir, "#{segment}_%04d.csv" % file_number)
-          end
-
-          def combine_dataframes(files)
-            dfs = files.map { |file| df(file) }
-            Polars.concat(dfs)
-          end
-        end
-      end
-    end
-  end
-end