easy_ml 0.1.4 → 0.2.0.pre.rc1

data/app/models/easy_ml/splitters/predefined_splitter.rb

@@ -0,0 +1,74 @@
+module EasyML
+  module Splitters
+    class PredefinedSplitter < BaseSplitter
+      validates :train_files, :test_files, :valid_files, presence: true
+      validate :files_must_be_unique
+      validate :at_least_one_file_specified
+
+      add_configuration_attributes :train_files, :test_files, :valid_files
+
+      def self.default_config
+        {
+          train_files: ["train.csv"],
+          test_files: ["test.csv"],
+          valid_files: ["valid.csv"],
+        }
+      end
+
+      def split(datasource, &block)
+        validate!
+
+        files = datasource.all_files
+        train, valid, test = match_files(files)
+
+        yield [reader.query(train), reader.query(valid), reader.query(test)]
+      end
+
+      def match_files(files)
+        train = select_preferred_files(files.select { |file| match_file(file, train_files) })
+        test = select_preferred_files(files.select { |file| match_file(file, test_files) })
+        valid = select_preferred_files(files.select { |file| match_file(file, valid_files) })
+
+        [train, valid, test]
+      end
+
+      def select_preferred_files(files)
+        # Group files by their base name (without extensions)
+        grouped = files.group_by { |f| Pathname.new(f).basename.to_s.gsub(/\.parquet$/, "").gsub(/\.[^.]+$/, "") }
+
+        # For each group, prefer parquet if it exists, otherwise use csv
+        grouped.map do |_, group_files|
+          parquet_file = group_files.find { |f| f.end_with?(".parquet") }
+          parquet_file || group_files.first
+        end
+      end
+
+      def match_file(file, type)
+        base_name = Pathname.new(file).basename.to_s
+        # Strip both .parquet and original extension
+        filename = base_name.gsub(/\.parquet$/, "").gsub(/\.[^.]+$/, "")
+
+        type.map { |f| f.gsub(/\.[^.]+$/, "") }.include?(filename)
+      end
+
+      private
+
+      def reader
+        @reader ||= EasyML::Data::PolarsReader.new
+      end
+
+      def files_must_be_unique
+        all_files = train_files + test_files + valid_files
+        if all_files.uniq.length != all_files.length
+          errors.add(:base, "Files must be unique across splits")
+        end
+      end
+
+      def at_least_one_file_specified
+        if train_files.empty? && test_files.empty? && valid_files.empty?
+          errors.add(:base, "At least one file must be specified")
+        end
+      end
+    end
+  end
+end

data/app/models/easy_ml/splitters/random_splitter.rb

@@ -0,0 +1,82 @@
+# == Schema Information
+#
+# Table name: easy_ml_splitters
+#
+#  id            :bigint           not null, primary key
+#  splitter_type :string           not null
+#  configuration :json
+#  dataset_id    :bigint           not null
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+require_relative "base_splitter"
+
+module EasyML
+  module Splitters
+    class RandomSplitter < BaseSplitter
+      validates :train_ratio, presence: true, numericality: { greater_than: 0, less_than: 1 }
+      validates :valid_ratio, presence: true, numericality: { greater_than: 0, less_than: 1 }
+      validates :test_ratio, presence: true, numericality: { greater_than: 0, less_than: 1 }
+      validate :ratios_sum_to_one
+
+      attr_accessor :train_ratio, :valid_ratio, :test_ratio, :seed
+
+      add_configuration_attributes :train_ratio, :valid_ratio, :test_ratio, :seed
+
+      def self.default_config
+        {}
+      end
+
+      def split_df(df)
+        set_defaults
+
+        # Set random seed if provided for reproducibility
+        rng = seed ? Random.new(seed.to_i) : Random.new
+
+        # Get total number of rows
+        n_rows = df.height
+
+        # Generate a deterministic random order based on the seed
+        shuffled_indices = (0...n_rows).to_a.shuffle(random: rng || Random.new)
+
+        # Calculate split sizes
+        train_size = (n_rows * train_ratio).floor
+        valid_size = (n_rows * valid_ratio).floor
+
+        # Split indices
+        train_indices = shuffled_indices[0...train_size]
+        valid_indices = shuffled_indices[train_size...(train_size + valid_size)]
+        test_indices = shuffled_indices[(train_size + valid_size)..]
+
+        # Add an index column to filter
+        df_with_index = df.with_columns([
+          Polars.arange(0, n_rows).alias("index"),
+        ])
+
+        # Filter rows by index for train, validation, and test sets
+        train_df = df_with_index.filter(Polars.col("index").is_in(train_indices)).drop("index")
+        valid_df = df_with_index.filter(Polars.col("index").is_in(valid_indices)).drop("index")
+        test_df = df_with_index.filter(Polars.col("index").is_in(test_indices)).drop("index")
+
+        [train_df, valid_df, test_df]
+      end
+
+      private
+
+      def set_defaults
+        self.train_ratio ||= 0.6
+        self.valid_ratio ||= 0.2
+        self.test_ratio ||= 0.2
+      end
+
+      def ratios_sum_to_one
+        return unless train_ratio && valid_ratio && test_ratio
+
+        sum = train_ratio + valid_ratio + test_ratio
+        return if (sum - 1.0).abs < 1e-10 # Using small epsilon for float comparison
+
+        errors.add(:base, "Split ratios must sum to 1.0 (got #{sum})")
+      end
+    end
+  end
+end

data/app/models/easy_ml/tuner_job.rb

@@ -0,0 +1,56 @@
+# == Schema Information
+#
+# Table name: easy_ml_tuner_jobs
+#
+#  id                :bigint           not null, primary key
+#  config            :json             not null
+#  best_tuner_run_id :bigint
+#  model_id          :bigint           not null
+#  status            :string
+#  direction         :string           default("minimize")
+#  started_at        :datetime
+#  completed_at      :datetime
+#  metadata          :jsonb
+#  wandb_url         :string
+#  created_at        :datetime         not null
+#  updated_at        :datetime         not null
+#
+module EasyML
+  class TunerJob < ActiveRecord::Base
+    self.table_name = "easy_ml_tuner_jobs"
+
+    belongs_to :model
+    belongs_to :best_tuner_run, class_name: "EasyML::TunerRun", optional: true
+    has_many :tuner_runs, dependent: :destroy
+
+    validates :config, presence: true
+    validates :direction, inclusion: { in: %w[minimize maximize] }
+
+    enum status: {
+      pending: "pending",
+      running: "running",
+      success: "success",
+      failed: "failed",
+    }
+
+    def best_run
+      return nil if tuner_runs.empty?
+
+      tuner_runs.order(value: direction_order).first
+    end
+
+    def self.constants
+      EasyML::Model::MODEL_OPTIONS.inject({}) do |h, (key, class_name)|
+        h.tap do
+          h[key] = class_name.constantize.hyperparameter_constants
+        end
+      end
+    end
+
+    private
+
+    def direction_order
+      direction == "minimize" ? :asc : :desc
+    end
+  end
+end

data/app/models/easy_ml/tuner_run.rb

@@ -0,0 +1,31 @@
+# == Schema Information
+#
+# Table name: easy_ml_tuner_runs
+#
+#  id              :bigint           not null, primary key
+#  tuner_job_id    :bigint           not null
+#  hyperparameters :json             not null
+#  value           :float
+#  trial_number    :integer
+#  status          :string
+#  wandb_url       :string
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+module EasyML
+  class TunerRun < ActiveRecord::Base
+    self.table_name = "easy_ml_tuner_runs"
+
+    belongs_to :tuner_job
+
+    validates :hyperparameters, presence: true
+    validates :trial_number, presence: true, uniqueness: { scope: :tuner_job_id }
+
+    enum status: {
+      pending: "pending",
+      running: "running",
+      success: "success",
+      failed: "failed",
+    }
+  end
+end

data/app/models/splitter_history.rb

@@ -0,0 +1,6 @@
+module EasyML
+  class SplitterHistory < ActiveRecord::Base
+    self.table_name = "easy_ml_splitter_histories"
+    include Historiographer::History
+  end
+end

data/app/serializers/easy_ml/column_serializer.rb

@@ -0,0 +1,27 @@
+# == Schema Information
+#
+# Table name: easy_ml_columns
+#
+#  id                  :bigint           not null, primary key
+#  dataset_id          :bigint           not null
+#  name                :string           not null
+#  description         :string
+#  datatype            :string
+#  polars_datatype     :string
+#  is_target           :boolean
+#  hidden              :boolean          default(FALSE)
+#  drop_if_null        :boolean          default(FALSE)
+#  preprocessing_steps :json
+#  sample_values       :json
+#  statistics          :json
+#  created_at          :datetime         not null
+#  updated_at          :datetime         not null
+#
+module EasyML
+  class ColumnSerializer
+    include JSONAPI::Serializer
+
+    attributes :id, :name, :description, :dataset_id, :datatype, :polars_datatype, :preprocessing_steps,
+               :hidden, :drop_if_null, :sample_values, :statistics, :is_target
+  end
+end

data/app/serializers/easy_ml/dataset_serializer.rb

@@ -0,0 +1,73 @@
+require_relative "./column_serializer"
+
+# == Schema Information
+#
+# Table name: easy_ml_datasets
+#
+#  id                      :bigint           not null, primary key
+#  name                    :string           not null
+#  description             :string
+#  dataset_type            :string
+#  status                  :string
+#  version                 :string
+#  datasource_id           :bigint
+#  root_dir                :string
+#  configuration           :json
+#  num_rows                :bigint
+#  workflow_status         :string
+#  statistics              :json
+#  preprocessor_statistics :json
+#  schema                  :json
+#  refreshed_at            :datetime
+#  created_at              :datetime         not null
+#  updated_at              :datetime         not null
+#
+module EasyML
+  class DatasetSerializer
+    include JSONAPI::Serializer
+
+    attributes :id, :name, :description, :target, :num_rows, :status,
+               :datasource_id, :preprocessing_steps, :workflow_status, :statistics
+
+    attribute :splitter do |dataset|
+      dataset.splitter
+    end
+
+    attribute :columns do |dataset|
+      dataset.columns.order(:id).map do |column|
+        ColumnSerializer.new(column).serializable_hash.dig(:data, :attributes)
+      end
+    end
+
+    attribute :sample_data do |dataset|
+      if dataset.workflow_status.to_sym == :analyzing
+        nil
+      else
+        dataset.data(limit: 10, all_columns: true)&.to_hashes
+      end
+    end
+
+    attribute :updated_at do |dataset|
+      dataset.datasource&.last_updated_at
+    end
+
+    attribute :features do |dataset|
+      dataset.features.ordered.map do |feature|
+        FeatureSerializer.new(feature).serializable_hash.dig(:data, :attributes)
+      end
+    end
+
+    attribute :needs_refresh do |dataset|
+      dataset.needs_refresh?
+    end
+
+    attribute :stacktrace do |object|
+      if !object.failed? || object.events.empty?
+        nil
+      else
+        last_event = object.events.order(id: :desc).limit(1).last
+        last_event&.stacktrace if last_event&.status == "failed"
+      end
+    end
+  end
+end

data/app/serializers/easy_ml/datasource_serializer.rb

@@ -0,0 +1,64 @@
+# == Schema Information
+#
+# Table name: easy_ml_datasources
+#
+#  id              :bigint           not null, primary key
+#  name            :string           not null
+#  datasource_type :string
+#  root_dir        :string
+#  configuration   :json
+#  created_at      :datetime         not null
+#  updated_at      :datetime         not null
+#
+require "jsonapi/serializer"
+
+module EasyML
+  class DatasourceSerializer
+    include JSONAPI::Serializer
+
+    set_type :datasource # Optional type for JSON:API
+
+    attributes :id, :name, :datasource_type, :s3_bucket, :s3_prefix, :s3_region, :schema, :columns, :available_files
+
+    attribute :last_synced_at do |datasource|
+      if datasource.is_syncing
+        "Syncing..."
+      else
+        datasource.last_updated_at ? datasource.last_updated_at.in_time_zone(EasyML::Configuration.timezone) : "Not Synced"
+      end
+    end
+
+    attribute :created_at do |datasource|
+      datasource.created_at.in_time_zone(EasyML::Configuration.timezone).iso8601
+    end
+
+    attribute :updated_at do |datasource|
+      datasource.updated_at.in_time_zone(EasyML::Configuration.timezone).iso8601
+    end
+
+    attribute :is_synced do |datasource|
+      datasource.last_updated_at.present?
+    end
+
+    attribute :is_syncing do |datasource|
+      datasource.is_syncing
+    end
+
+    attribute :sync_failed do |datasource|
+      if datasource.is_syncing
+        nil
+      else
+        datasource.events.order(id: :desc).limit(1)&.last&.status == "failed"
+      end
+    end
+
+    attribute :stacktrace do |datasource|
+      if datasource.is_syncing
+        nil
+      else
+        last_event = datasource.events.order(id: :desc).limit(1).last
+        last_event&.stacktrace if last_event&.status == "failed"
+      end
+    end
+  end
+end

data/app/serializers/easy_ml/feature_serializer.rb

@@ -0,0 +1,27 @@
+# == Schema Information
+#
+# Table name: easy_ml_
+#
+#  id                 :bigint           not null, primary key
+#  dataset_id         :bigint           not null
+#  name               :string
+#  feature_class    :string           not null
+#  feature_method   :string           not null
+#  feature_position :integer
+#  applied_at         :datetime
+#  created_at         :datetime         not null
+#  updated_at         :datetime         not null
+#
+require "jsonapi/serializer"
+
+module EasyML
+  class FeatureSerializer
+    include JSONAPI::Serializer
+
+    attributes :id, :feature_class, :feature_position, :name
+
+    attribute :description do |feature|
+      (EasyML::Features::Registry.find(feature.name) || {}).dig(:description)
+    end
+  end
+end

data/app/serializers/easy_ml/model_serializer.rb

@@ -0,0 +1,90 @@
+# == Schema Information
+#
+# Table name: easy_ml_models
+#
+#  id            :bigint           not null, primary key
+#  name          :string           not null
+#  model_type    :string
+#  status        :string
+#  dataset_id    :bigint
+#  model_file_id :bigint
+#  configuration :json
+#  version       :string           not null
+#  root_dir      :string
+#  file          :json
+#  sha           :string
+#  created_at    :datetime         not null
+#  updated_at    :datetime         not null
+#
+require "jsonapi/serializer"
+
+module EasyML
+  class ModelSerializer
+    include JSONAPI::Serializer
+
+    attributes :id,
+               :name,
+               :model_type,
+               :task,
+               :objective,
+               :metrics,
+               :dataset_id,
+               :status,
+               :deployment_status,
+               :configuration,
+               :created_at,
+               :updated_at,
+               :last_run_at
+
+    attribute :is_training do |object|
+      object.training?
+    end
+
+    attribute :last_run do |object|
+      RetrainingRunSerializer.new(object.last_run).serializable_hash.dig(:data, :attributes)
+    end
+
+    attribute :metrics_url do |object|
+      object.last_run&.wandb_url
+    end
+
+    attribute :retraining_runs do |object, params|
+      limit = params[:limit] || 20
+      offset = params[:offset] || 0
+
+      runs = object.retraining_runs
+        .order(created_at: :desc)
+        .offset(offset)
+        .limit(limit)
+
+      {
+        runs: RetrainingRunSerializer.new(runs).serializable_hash[:data].map { |run| run[:attributes] },
+        total_count: object.retraining_runs.count,
+        limit: limit,
+        offset: offset,
+        next_offset: offset + limit,
+        prev_offset: offset - limit,
+      }
+    end
+
+    attribute :version do |object|
+      object.formatted_version
+    end
+
+    attribute :formatted_model_type do |object|
+      object.formatted_model_type
+    end
+
+    attribute :formatted_frequency do |object|
+      object.retraining_job.present? ? object.retraining_job.formatted_frequency : nil
+    end
+
+    attribute :dataset do |object|
+      DatasetSerializer.new(object.dataset).serializable_hash.dig(:data, :attributes)
+    end
+
+    attribute :retraining_job do |object|
+      RetrainingJobSerializer.new(object.retraining_job).serializable_hash.dig(:data, :attributes)
+    end
+  end
+end

data/app/serializers/easy_ml/retraining_job_serializer.rb

@@ -0,0 +1,22 @@
+require "jsonapi/serializer"
+
+module EasyML
+  class RetrainingJobSerializer
+    include JSONAPI::Serializer
+
+    attributes :id,
+               :active,
+               :frequency,
+               :formatted_frequency,
+               :tuning_frequency,
+               :at,
+               :metric,
+               :threshold,
+               :tuner_config,
+               :batch_mode,
+               :batch_size,
+               :batch_overlap,
+               :batch_key,
+               :tuning_enabled
+  end
+end

data/app/serializers/easy_ml/retraining_run_serializer.rb

@@ -0,0 +1,39 @@
+require "jsonapi/serializer"
+
+module EasyML
+  class RetrainingRunSerializer
+    include JSONAPI::Serializer
+
+    attributes :id,
+               :deployable,
+               :metrics,
+               :metric_value,
+               :threshold,
+               :threshold_direction,
+               :status,
+               :error_message,
+               :is_deploying,
+               :deployed
+
+    attribute :metrics_url do |run|
+      run.wandb_url
+    end
+
+    attribute :started_at do |run|
+      run.started_at&.in_time_zone(EasyML::Configuration.timezone)
+    end
+
+    attribute :completed_at do |run|
+      run.completed_at&.in_time_zone(EasyML::Configuration.timezone)
+    end
+
+    attribute :stacktrace do |object|
+      if object.status.to_s == "running"
+        nil
+      else
+        last_event = object.events.order(id: :desc).limit(1).last
+        last_event&.stacktrace if last_event&.status.to_s == "failed"
+      end
+    end
+  end
+end

data/app/serializers/easy_ml/settings_serializer.rb

@@ -0,0 +1,9 @@
+require "jsonapi/serializer"
+
+module EasyML
+  class SettingsSerializer
+    include JSONAPI::Serializer
+
+    attributes *EasyML::Settings.configuration_attributes
+  end
+end

data/app/views/layouts/easy_ml/application.html.erb

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>EasyML</title>
+    <%= csrf_meta_tags %>
+    <%= csp_meta_tag %>
+    
+    <%= vite_client_tag %>
+    <%= vite_react_refresh_tag %>
+    <%= vite_typescript_tag 'Application.tsx' %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html> 

data/config/initializers/resque.rb

@@ -0,0 +1,3 @@
+require 'resque'
+Resque.redis = ENV['REDIS_URL'] || 'redis://localhost:6379'
+

data/config/resque-pool.yml

@@ -0,0 +1,6 @@
+development:
+  '*': 2
+
+production:
+  '*': <%= ENV['WORKER_COUNT'] || 5 %>
+

data/config/routes.rb

@@ -0,0 +1,39 @@
+EasyML::Engine.routes.draw do
+  root to: "models#index"
+
+  resources :models, as: :easy_ml_models do
+    member do
+      post :train
+      get :retraining_runs, to: "retraining_runs#index"
+    end
+    resources :deploys, only: [:create]
+    get "new", on: :collection, as: "new"
+  end
+
+  resources :retraining_runs, only: [:show]
+
+  # Datasources
+  resources :datasources, as: :easy_ml_datasources do
+    member do
+      post :sync
+    end
+  end
+
+  # Datasets
+  resources :datasets, as: :easy_ml_datasets do
+    member do
+      post :refresh
+    end
+  end
+
+  # Transformations
+  resources :transformations, only: %i[index new edit], as: :easy_ml_transformations
+
+  # Settings
+  resources :settings, only: [:index] do
+    patch :update, on: :collection
+  end
+
+  # Columns
+  resources :columns, only: [:update], as: :easy_ml_columns
+end

data/config/spring.rb

@@ -0,0 +1 @@
+Spring.application_root = "./spec/internal"