easy_ml 0.1.4 → 0.2.0.pre.rc1

data/app/models/easy_ml/model_file.rb

@@ -0,0 +1,133 @@
+# == Schema Information
+#
+# Table name: easy_ml_model_files
+#
+#  id            :bigint           not null, primary key
+#  filename      :string           not null
+#  path          :string           not null
+#  configuration :json
+#  model_type    :string
+#  model_id      :bigint
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+module EasyML
+  class ModelFile < ActiveRecord::Base
+    self.table_name = "easy_ml_model_files"
+    include Historiographer::Silent
+    historiographer_mode :snapshot_only
+
+    self.filter_attributes += [:configuration]
+
+    validates :filename, presence: true
+    belongs_to :model, class_name: "EasyML::Model"
+
+    include EasyML::Concerns::Configurable
+    add_configuration_attributes :s3_bucket, :s3_prefix, :s3_region, :s3_access_key_id, :s3_secret_access_key, :root_dir
+
+    def synced_file
+      EasyML::Support::SyncedFile.new(
+        filename: filename,
+        s3_bucket: s3_bucket,
+        s3_prefix: s3_prefix,
+        s3_region: s3_region,
+        s3_access_key_id: s3_access_key_id,
+        s3_secret_access_key: s3_secret_access_key,
+        root_dir: root_dir,
+      )
+    end
+
+    def exist?
+      fit?
+    end
+
+    def fit?
+      return false if root_dir.nil?
+      return false if full_path.nil?
+
+      File.exist?(full_path)
+    end
+
+    def read
+      File.read(full_path)
+    end
+
+    def upload(path)
+      synced_file.upload(path)
+      set_path(path)
+    end
+
+    def set_path(path)
+      path = get_full_path(path)
+      basename = Pathname.new(path).basename.to_s
+      unless path.start_with?(full_dir)
+        new_path = File.join(full_dir, basename).to_s
+        FileUtils.mkdir_p(Pathname.new(new_path).dirname.to_s)
+        FileUtils.cp(path, new_path)
+        path = new_path
+      end
+      self.filename = basename
+      self.path = get_relative_path(path)
+    end
+
+    def get_full_path(path)
+      path = path.to_s
+
+      path = Rails.root.join(path) unless path.match?(Regexp.new(Rails.root.to_s))
+      path
+    end
+
+    def get_relative_path(path)
+      path = path.to_s
+      path = path.to_s.split(Rails.root.to_s).last
+      path.to_s.split("/")[0..-2].reject(&:empty?).join("/")
+    end
+
+    def download
+      return unless full_path.present?
+
+      synced_file.download(full_path) unless File.exist?(full_path)
+      full_path
+    end
+
+    def sha
+      Digest::SHA256.file(full_path).hexdigest
+    end
+
+    def full_path(filename = nil)
+      filename = self.filename if filename.nil?
+      return nil if filename.nil?
+      return nil if relative_dir.nil?
+
+      Rails.root.join(relative_dir, filename).to_s
+    end
+
+    def relative_dir
+      root_dir.to_s.gsub(Regexp.new(Rails.root.to_s), "").gsub!(%r{^/}, "")
+    end
+
+    def full_dir
+      Rails.root.join(relative_dir).to_s
+    end
+
+    def model_root
+      File.expand_path("..", full_dir)
+    end
+
+    def cleanup!
+      [model_root].each do |dir|
+        EasyML::Support::FileRotate.new(dir, []).cleanup(extension_allowlist)
+      end
+    end
+
+    def cleanup(files_to_keep)
+      [model_root].each do |dir|
+        EasyML::Support::FileRotate.new(dir, files_to_keep).cleanup(extension_allowlist)
+      end
+    end
+
+    def extension_allowlist
+      %w[bin model json]
+    end
+  end
+end

data/app/models/easy_ml/model_file_history.rb

@@ -0,0 +1,24 @@
+# == Schema Information
+#
+# Table name: easy_ml_model_file_histories
+#
+#  id                 :bigint           not null, primary key
+#  model_file_id      :integer          not null
+#  filename           :string           not null
+#  path               :string           not null
+#  configuration      :json
+#  model_type         :string
+#  model_id           :integer
+#  created_at         :datetime         not null
+#  updated_at         :datetime         not null
+#  history_started_at :datetime         not null
+#  history_ended_at   :datetime
+#  history_user_id    :integer
+#  snapshot_id        :string
+#
+module EasyML
+  class ModelFileHistory < ActiveRecord::Base
+    self.table_name = "easy_ml_model_file_histories"
+    include Historiographer::History
+  end
+end

data/app/models/easy_ml/model_history.rb

@@ -0,0 +1,51 @@
+# == Schema Information
+#
+# Table name: easy_ml_model_histories
+#
+#  id                 :bigint           not null, primary key
+#  model_id           :integer          not null
+#  name               :string           not null
+#  model_type         :string
+#  status             :string
+#  dataset_id         :integer
+#  model_file_id      :integer
+#  configuration      :json
+#  version            :string           not null
+#  root_dir           :string
+#  file               :json
+#  sha                :string
+#  last_trained_at    :datetime
+#  is_training        :boolean
+#  created_at         :datetime         not null
+#  updated_at         :datetime         not null
+#  history_started_at :datetime         not null
+#  history_ended_at   :datetime
+#  history_user_id    :integer
+#  snapshot_id        :string
+#
+module EasyML
+  class ModelHistory < ActiveRecord::Base
+    self.table_name = "easy_ml_model_histories"
+    include Historiographer::History
+
+    scope :deployed, -> {
+        where(id: EasyML::Deploy.latest.includes(:model_version).map(&:model_version).compact.map(&:id))
+      }
+
+    def status
+      @status ||= if is_deployed?
+          :inference
+        else
+          :retired
+        end
+    end
+
+    def is_deployed?
+      EasyML::Deploy.latest.where(model_id: model_id)&.first&.model_version&.id == id
+    end
+
+    def fit
+      raise "Cannot train inference model"
+    end
+  end
+end

data/app/models/easy_ml/models/base_model.rb

@@ -0,0 +1,58 @@
+module EasyML
+  module Models
+    class BaseModel
+      include ActiveModel::Validations
+      include EasyML::Concerns::Configurable
+      include EasyML::Support::FileSupport
+
+      attr_reader :model
+
+      add_configuration_attributes :hyperparameters
+
+      def initialize(model)
+        @model = model
+      end
+
+      delegate :task, :dataset, :hyperparameters, to: :model
+
+      # Required interface methods that subclasses must implement
+      def predict(_xs)
+        raise NotImplementedError, "#{self.class} must implement #predict"
+      end
+
+      def fit(_x_train = nil)
+        raise NotImplementedError, "#{self.class} must implement #fit"
+      end
+
+      def model_changed?
+        raise NotImplementedError, "#{self.class} must implement #model_changed?"
+      end
+
+      def feature_importances
+        raise NotImplementedError, "#{self.class} must implement #feature_importances"
+      end
+
+      def save_model_file(path)
+        raise NotImplementedError, "#{self.class} must implement #save_model_file"
+      end
+
+      def load_model_file(path)
+        raise NotImplementedError, "#{self.class} must implement #load_model_file"
+      end
+
+      def loaded?
+        raise NotImplementedError, "#{self.class} must implement #loaded?"
+      end
+
+      protected
+
+      def validate_objective
+        raise NotImplementedError, "#{self.class} must implement #validate_objective"
+      end
+
+      def validate_hyperparameters
+        raise NotImplementedError, "#{self.class} must implement #validate_hyperparameters"
+      end
+    end
+  end
+end

data/app/models/easy_ml/models/hyperparameters/base.rb

@@ -0,0 +1,99 @@
+module EasyML
+  module Models
+    module Hyperparameters
+      class Base
+        attr_accessor :learning_rate, :max_iterations, :batch_size,
+                      :regularization, :early_stopping_rounds
+
+        def initialize(options = {})
+          @learning_rate = options[:learning_rate] || 0.01
+          @max_iterations = options[:max_iterations] || 100
+          @batch_size = options[:batch_size] || 32
+          @regularization = options[:regularization] || 0.0001
+          @early_stopping_rounds = options[:early_stopping_rounds]
+        end
+
+        def self.common_tree_params
+          {
+            learning_rate: {
+              label: "Learning Rate",
+              description: "Step size shrinkage used to prevent overfitting",
+              min: 0.001,
+              max: 0.3,
+              step: 0.001,
+            },
+            max_depth: {
+              label: "Maximum Tree Depth",
+              description: "Maximum depth of a tree",
+              min: 3,
+              max: 10,
+              step: 1,
+            },
+            n_estimators: {
+              label: "Number of Trees",
+              description: "Number of boosting rounds",
+              min: 100,
+              max: 1000,
+              step: 1,
+            },
+            early_stopping_rounds: {
+              label: "Early Stopping Rounds",
+              description: "Number of rounds to check for early stopping",
+              min: 1,
+              max: 5,
+              step: 1,
+            },
+          }
+        end
+
+        def self.common_regularization_params
+          {
+            lambda: {
+              label: "L2 Regularization",
+              description: "L2 regularization term on weights",
+              min: 0,
+              max: 10,
+              step: 0.1,
+            },
+            alpha: {
+              label: "L1 Regularization",
+              description: "L1 regularization term on weights",
+              min: 0,
+              max: 1,
+              step: 0.1,
+            },
+            early_stopping_rounds: {
+              label: "Early Stopping Rounds",
+              description: "Number of rounds to check for early stopping",
+              min: 1,
+              max: 5,
+              step: 1,
+            },
+          }
+        end
+
+        def to_h
+          instance_variables.each_with_object({}) do |var, hash|
+            hash[var.to_s.delete("@").to_sym] = instance_variable_get(var)
+          end.with_indifferent_access
+        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/app/models/easy_ml/models/hyperparameters/xgboost/dart.rb

@@ -0,0 +1,82 @@
+module EasyML
+  module Models
+    module Hyperparameters
+      class XGBoost
+        class Dart < XGBoost
+          attr_accessor :rate_drop, :skip_drop, :sample_type, :normalize_type,
+                        :subsample, :colsample_bytree
+
+          def initialize(options = {})
+            super
+            @rate_drop = options[:rate_drop] || 0.0
+            @skip_drop = options[:skip_drop] || 0.0
+            @sample_type = options[:sample_type] || "uniform"
+            @normalize_type = options[:normalize_type] || "tree"
+            @subsample = options[:subsample] || 1.0
+            @colsample_bytree = options[:colsample_bytree] || 1.0
+            validate!
+          end
+
+          def validate!
+            unless %w[uniform weighted].include?(@sample_type)
+              raise ArgumentError, "Invalid sample_type: #{@sample_type}"
+            end
+            unless %w[tree forest].include?(@normalize_type)
+              raise ArgumentError, "Invalid normalize_type: #{@normalize_type}"
+            end
+          end
+
+          def self.hyperparameter_constants
+            # DART uses all tree parameters since it's tree-based
+            Base.common_tree_params.merge(Base.common_regularization_params).merge(
+              rate_drop: {
+                label: "Dropout Rate",
+                description: "Dropout rate (a fraction of previous trees to drop)",
+                min: 0,
+                max: 1,
+                step: 0.1,
+              },
+              skip_drop: {
+                label: "Skip Dropout",
+                description: "Probability of skipping the dropout procedure during iteration",
+                min: 0,
+                max: 1,
+                step: 0.1,
+              },
+              sample_type: {
+                label: "Sample Type",
+                options: [
+                  {
+                    value: "uniform",
+                    label: "Uniform",
+                    description: "Dropped trees are selected uniformly",
+                  },
+                  {
+                    value: "weighted",
+                    label: "Weighted",
+                    description: "Dropped trees are selected in proportion to weight",
+                  },
+                ],
+              },
+              normalize_type: {
+                label: "Normalize Type",
+                options: [
+                  {
+                    value: "tree",
+                    label: "Tree",
+                    description: "New trees have the same weight of dropped trees divided by k",
+                  },
+                  {
+                    value: "forest",
+                    label: "Forest",
+                    description: "New trees have the same weight of sum of dropped trees",
+                  },
+                ],
+              },
+            ).merge(GBTree.hyperparameter_constants) # Include GBTree params since DART is tree-based
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/easy_ml/models/hyperparameters/xgboost/gblinear.rb

@@ -0,0 +1,82 @@
+module EasyML
+  module Models
+    module Hyperparameters
+      class XGBoost
+        class GBLinear < XGBoost
+          attr_accessor :updater, :feature_selector, :lambda, :alpha
+
+          def initialize(options = {})
+            super
+            @updater = options[:updater] || "shotgun"
+            @feature_selector = options[:feature_selector] || "cyclic"
+            @lambda = options[:lambda] || 1.0
+            @alpha = options[:alpha] || 0.0
+            validate!
+          end
+
+          def validate!
+            unless %w[shotgun coord_descent].include?(@updater)
+              raise ArgumentError, "Invalid updater: #{@updater}"
+            end
+            unless %w[cyclic shuffle greedy thrifty].include?(@feature_selector)
+              raise ArgumentError, "Invalid feature_selector: #{@feature_selector}"
+            end
+          end
+
+          def self.hyperparameter_constants
+            # GBLinear only uses learning_rate from tree params
+            { learning_rate: Base.common_tree_params[:learning_rate] }
+              .merge(Base.common_regularization_params)
+              .merge(
+                feature_selector: {
+                  label: "Feature Selector",
+                  options: [
+                    {
+                      value: "cyclic",
+                      label: "Cyclic",
+                      description: "Update features in a cyclic order"
+                    },
+                    {
+                      value: "shuffle",
+                      label: "Shuffle",
+                      description: "Update features in a random order"
+                    },
+                    {
+                      value: "random",
+                      label: "Random",
+                      description: "Randomly select features to update"
+                    },
+                    {
+                      value: "greedy",
+                      label: "Greedy",
+                      description: "Select features with the highest gradient magnitude"
+                    },
+                    {
+                      value: "thrifty",
+                      label: "Thrifty",
+                      description: "Thrifty, approximated greedy algorithm"
+                    }
+                  ]
+                },
+                updater: {
+                  label: "Updater",
+                  options: [
+                    {
+                      value: "shotgun",
+                      label: "Shotgun",
+                      description: "Parallel coordinate descent algorithm"
+                    },
+                    {
+                      value: "coord_descent",
+                      label: "Coordinate Descent",
+                      description: "Ordinary coordinate descent algorithm"
+                    }
+                  ]
+                }
+              )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/easy_ml/models/hyperparameters/xgboost/gbtree.rb

@@ -0,0 +1,97 @@
+module EasyML
+  module Models
+    module Hyperparameters
+      class XGBoost
+        class GBTree < XGBoost
+          attr_accessor :max_depth, :min_child_weight, :max_delta_step, :subsample,
+                        :colsample_bytree, :colsample_bylevel, :colsample_bynode,
+                        :tree_method, :gamma, :scale_pos_weight
+
+          def initialize(options = {})
+            super
+            @max_depth = options[:max_depth] || 6
+            @min_child_weight = options[:min_child_weight] || 1
+            @max_delta_step = options[:max_delta_step] || 0
+            @subsample = options[:subsample] || 1.0
+            @colsample_bytree = options[:colsample_bytree] || 1.0
+            @colsample_bylevel = options[:colsample_bylevel] || 1.0
+            @colsample_bynode = options[:colsample_bynode] || 1.0
+            @tree_method = options[:tree_method] || "auto"
+            @gamma = options[:gamma] || 0.0
+            @scale_pos_weight = options[:scale_pos_weight] || 1.0
+            validate!
+          end
+
+          def validate!
+            unless %w[auto exact approx hist gpu_hist].include?(@tree_method)
+              raise ArgumentError, "Invalid tree_method: #{@tree_method}"
+            end
+          end
+
+          def self.hyperparameter_constants
+            Base.common_tree_params.merge(Base.common_regularization_params).merge(
+              min_child_weight: {
+                label: "Minimum Child Weight",
+                description: "Minimum sum of instance weight needed in a child",
+                min: 0,
+                max: 10,
+                step: 0.1,
+              },
+              gamma: {
+                label: "Gamma",
+                description: "Minimum loss reduction required to make a further partition",
+                min: 0,
+                max: 10,
+                step: 0.1,
+              },
+              subsample: {
+                label: "Subsample Ratio",
+                description: "Subsample ratio of the training instances",
+                min: 0.1,
+                max: 1,
+                step: 0.1,
+              },
+              colsample_bytree: {
+                label: "Column Sample by Tree",
+                description: "Subsample ratio of columns when constructing each tree",
+                min: 0.1,
+                max: 1,
+                step: 0.1,
+              },
+              tree_method: {
+                label: "Tree Construction Method",
+                options: [
+                  {
+                    value: "auto",
+                    label: "Auto",
+                    description: "Use heuristic to choose the fastest method",
+                  },
+                  {
+                    value: "exact",
+                    label: "Exact",
+                    description: "Exact greedy algorithm",
+                  },
+                  {
+                    value: "approx",
+                    label: "Approximate",
+                    description: "Approximate greedy algorithm using sketching and histogram",
+                  },
+                  {
+                    value: "hist",
+                    label: "Histogram",
+                    description: "Fast histogram optimized approximate greedy algorithm",
+                  },
+                  {
+                    value: "gpu_hist",
+                    label: "GPU Histogram",
+                    description: "GPU implementation of hist algorithm",
+                  },
+                ],
+              },
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/easy_ml/models/hyperparameters/xgboost.rb

@@ -0,0 +1,71 @@
+require_relative "base"
+
+module EasyML
+  module Models
+    module Hyperparameters
+      class XGBoost < Base
+        attr_accessor :learning_rate, :max_depth, :n_estimators, :booster,
+                      :objective, :lambda, :alpha
+
+        VALID_OBJECTIVES = %w[binary:logistic binary:hinge multi:softmax multi:softprob reg:squarederror reg:logistic].freeze
+        VALID_BOOSTERS = %w[gbtree gblinear dart].freeze
+
+        def initialize(options = {})
+          super
+          @learning_rate = options[:learning_rate] || 0.1
+          @max_depth = options[:max_depth] || 6
+          @n_estimators = options[:n_estimators] || 100
+          @booster = options[:booster] || "gbtree"
+          @objective = options[:objective] || "reg:squarederror"
+          @lambda = options[:lambda] || 1.0
+          @alpha = options[:alpha] || 0.0
+          validate! if self.class.name == "EasyML::Models::Hyperparameters::XGBoost"
+        end
+
+        def validate!
+          unless VALID_OBJECTIVES.include?(@objective)
+            raise ArgumentError, "Invalid objective. Must be one of: #{VALID_OBJECTIVES.join(", ")}"
+          end
+          unless VALID_BOOSTERS.include?(@booster)
+            raise ArgumentError, "Invalid booster. Must be one of: #{VALID_BOOSTERS.join(", ")}"
+          end
+        end
+
+        def self.hyperparameter_constants
+          {
+            booster: {
+              label: "XGBoost Booster",
+              options: [
+                {
+                  value: "gbtree",
+                  label: "Gradient Boosted Tree",
+                  description: "Traditional Gradient Boosting Decision Tree",
+                },
+                {
+                  value: "gblinear",
+                  label: "Gradient Boosted Linear",
+                  description: "Generalized Linear Model with gradient boosting",
+                },
+                {
+                  value: "dart",
+                  label: "DART",
+                  description: "Dropouts meet Multiple Additive Regression Trees",
+                },
+              ],
+            },
+            hyperparameters: {
+              depends_on: "booster",
+              gbtree: GBTree.hyperparameter_constants,
+              gblinear: GBLinear.hyperparameter_constants,
+              dart: Dart.hyperparameter_constants,
+            },
+          }
+        end
+      end
+    end
+  end
+end
+
+require_relative "xgboost/gbtree"
+require_relative "xgboost/gblinear"
+require_relative "xgboost/dart"