easy_ml 0.1.4 → 0.2.0.pre.rc1

data/app/frontend/types.ts

@@ -0,0 +1,113 @@
+import { Dataset } from './dataset';
+
+export type ModelStatus = 'success' | 'failed';
+export type DeploymentStatus = 'training' | 'inference' | 'retired';
+export type JobStatus = 'running' | 'success' | 'failed' | 'deployed';
+export type Frequency = 'hourly' | 'daily' | 'weekly' | 'monthly';
+export type ThresholdDirection = 'minimize' | 'maximize';
+export interface Feature {
+  id: number;
+  name: string;
+  description: string;
+  groupId: number;
+  testDatasetId: number;
+  inputColumns: string[];
+  outputColumns: string[];
+  code: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface FeatureGroup {
+  id: number;
+  name: string;
+  description: string;
+  features: Feature[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+interface ModelVersion {
+  id: number;
+  version: string;
+  status: ModelStatus;
+  deployment_status: DeploymentStatus;
+  configuration: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface Model {
+  id: number;
+  name: string;
+  model_type: string;
+  formatted_model_type: string;
+  task: string;
+  objective: string;
+  metrics: Record<string, unknown>;
+  status: ModelStatus;
+  deployment_status: DeploymentStatus;
+  dataset_id: number;
+  dataset: Dataset;
+  version: string;
+  configuration: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+  retraining_runs: RetrainingRun[];
+  last_run_at: string | null;
+  last_run: RetrainingRun | null;
+  retraining_job: RetrainingJob | null;
+  formatted_frequency: string | null;
+  is_training: boolean;
+  metrics_url: string | null;
+}
+
+export interface Prediction {
+  id: number;
+  modelId: number;
+  timestamp: string;
+  input: Record<string, any>;
+  output: any;
+  groundTruth?: any;
+  latencyMs: number;
+}
+
+export interface RetrainingJob {
+  id: number;
+  model: string;
+  frequency: Frequency;
+  formatted_frequency: string;
+  at: number;
+  evaluator: Record<string, unknown>;
+  tuner_config: Record<string, unknown>;
+  tuning_frequency: Frequency;
+  last_tuning_at: string | null;
+  active: boolean;
+  status: JobStatus;
+  last_run_at: string | null;
+  locked_at: string | null;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface RetrainingRun {
+  id: number;
+  model_id: number;
+  retraining_job_id: number;
+  tuner_job_id: number | null;
+  status: JobStatus;
+  metric_value: number | null;
+  threshold: number | null;
+  threshold_direction: ThresholdDirection;
+  deployable: boolean;
+  started_at: string | null;
+  is_deploying: boolean;
+  completed_at: string | null;
+  error_message: string | null;
+  metadata: Record<string, unknown>;
+  created_at: string;
+  updated_at: string;
+  stacktrace: string | null;
+  metrics: Record<string, number>;
+  metrics_url: string | null;
+}

data/app/helpers/easy_ml/application_helper.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module EasyML
+  module ApplicationHelper
+    # Override: Returns the engine assets manifest.
+    def vite_manifest
+      EasyML::Engine.vite_ruby.manifest
+    end
+  end
+end

data/app/jobs/easy_ml/application_job.rb

@@ -0,0 +1,21 @@
+module EasyML
+  class ApplicationJob < ActiveJob::Base
+    queue_as :easy_ml
+
+    def create_event(model, status, error = nil)
+      EasyML::Event.create_event(model, status, error)
+    end
+
+    def handle_error(model, error)
+      EasyML::Event.handle_error(model, error)
+    end
+
+    def format_stacktrace(error)
+      EasyML::Event.format_stacktrace(error)
+    end
+
+    def wrap_text(text, max_length)
+      EasyML::Event.wrap_text(text, max_length)
+    end
+  end
+end

data/app/jobs/easy_ml/batch_job.rb

@@ -0,0 +1,46 @@
+module EasyML
+  class BatchJob
+    extend Resque::Plugins::BatchedJob
+    @queue = :easy_ml
+
+    class << self
+      # Default or dynamically generated batch ID
+      def default_batch_id
+        "batch_#{name}_#{SecureRandom.uuid}"
+      end
+
+      # E.g. EasyML::ComputeFeatureBatchJob.enqueue_batch(features.map(&:id))
+      #
+      def enqueue_batch(args_list, batch_id = default_batch_id)
+        args_list = args_list.map { |arg| arg.is_a?(Array) ? arg : [arg] }
+        store_batch_arguments(batch_id, args_list)
+
+        args_list.each do |args|
+          Resque.enqueue_batched_job(self, batch_id, *args)
+        end
+
+        batch_id
+      end
+
+      private
+
+      # Store batch arguments in Redis
+      def store_batch_arguments(batch_id, args_list)
+        redis_key = "#{batch(batch_id)}:original_args"
+        redis.set(redis_key, Resque.encode(args_list))
+      end
+
+      # Fetch batch arguments from Redis
+      def fetch_batch_arguments(batch_id)
+        redis_key = "#{batch(batch_id)}:original_args"
+        stored_args = redis.get(redis_key)
+        stored_args ? Resque.decode(stored_args) : []
+      end
+
+      # Redis instance for storing batch arguments
+      def redis
+        Resque.redis
+      end
+    end
+  end
+end

data/app/jobs/easy_ml/compute_feature_job.rb

@@ -0,0 +1,19 @@
+module EasyML
+  class ComputeFeatureJob < BatchJob
+    @queue = :easy_ml
+
+    def self.perform(batch_id, options = {})
+      options.symbolize_keys!
+      feature_id = options.dig(:feature_id)
+      feature = EasyML::Feature.find(feature_id)
+      feature.fit_batch(options)
+    end
+
+    def self.after_batch_hook(batch_id, *args)
+      puts "After batch!"
+      feature_ids = fetch_batch_arguments(batch_id).flatten.map(&:symbolize_keys).pluck(:feature_id).uniq
+      dataset = EasyML::Feature.find_by(id: feature_ids.first).dataset
+      dataset.after_fit_features
+    end
+  end
+end

data/app/jobs/easy_ml/deploy_job.rb

@@ -0,0 +1,13 @@
+module EasyML
+  class DeployJob < ApplicationJob
+    def perform(id)
+      deploy = EasyML::Deploy.find(id)
+
+      begin
+        deploy.actually_deploy
+      rescue StandardError => e
+        handle_error(deploy, e)
+      end
+    end
+  end
+end

data/app/jobs/easy_ml/finalize_feature_job.rb

@@ -0,0 +1,15 @@
+module EasyML
+  module Jobs
+    class FinalizeFeatureJob < ApplicationJob
+      queue_as :features
+
+      def perform(feature_id)
+        feature = EasyML::Feature.find(feature_id)
+        feature.update!(
+          applied_at: Time.current,
+          needs_fit: false,
+        )
+      end
+    end
+  end
+end

data/app/jobs/easy_ml/refresh_dataset_job.rb

@@ -0,0 +1,32 @@
+module EasyML
+  class RefreshDatasetJob < ApplicationJob
+    def perform(id)
+      dataset = EasyML::Dataset.find(id)
+      puts "Refreshing dataset #{dataset.name}"
+      puts "Needs refresh? #{dataset.needs_refresh?}"
+      unless dataset.needs_refresh?
+        dataset.update(workflow_status: :ready)
+      end
+
+      create_event(dataset, "started")
+
+      begin
+        puts "Prepare! #{dataset.name}"
+        dataset.prepare
+        if dataset.features.needs_fit.any?
+          dataset.fit_features(async: true)
+          puts "Computing features!"
+        else
+          dataset.actually_refresh
+          puts "Done!"
+        end
+      rescue StandardError => e
+        puts "Error #{e.message}"
+        if Rails.env.test?
+          raise e
+        end
+        handle_error(dataset, e)
+      end
+    end
+  end
+end

data/app/jobs/easy_ml/schedule_retraining_job.rb

@@ -0,0 +1,11 @@
+module EasyML
+  class ScheduleRetrainingJob < ApplicationJob
+    queue_as :easy_ml
+
+    def perform
+      RetrainingJob.active.each do |job|
+        job.model.train
+      end
+    end
+  end
+end

data/app/jobs/easy_ml/sync_datasource_job.rb

@@ -0,0 +1,17 @@
+module EasyML
+  class SyncDatasourceJob < ApplicationJob
+    queue_as :easy_ml
+
+    def perform(id)
+      datasource = EasyML::Datasource.find(id)
+      create_event(datasource, "started")
+
+      begin
+        datasource.refresh
+      rescue StandardError => e
+        datasource.update!(is_syncing: false)
+        handle_error(datasource, e)
+      end
+    end
+  end
+end

data/app/jobs/easy_ml/training_job.rb

@@ -0,0 +1,62 @@
+module EasyML
+  class TrainingJob < ApplicationJob
+    class TrainingTimeoutError < StandardError; end
+
+    INACTIVITY_TIMEOUT = 15 # seconds
+
+    def perform(model_id)
+      @model = EasyML::Model.find_by(id: model_id)
+      return if @model.nil?
+
+      @last_activity = Time.current
+      setup_signal_traps
+      # @monitor_thread = start_monitor_thread
+
+      @model.actually_train do |iteration_info|
+        @last_activity = Time.current
+      end
+    ensure
+      #   @monitor_thread&.exit
+    end
+
+    private
+
+    def setup_signal_traps
+      # Handle graceful shutdown on SIGTERM
+      Signal.trap("TERM") do
+        puts "Received SIGTERM, cleaning up..."
+        cleanup("Training process terminated")
+        raise TrainingTimeoutError, "Training process terminated"
+      end
+
+      # Handle Ctrl+C
+      Signal.trap("INT") do
+        puts "Received SIGINT, cleaning up..."
+        cleanup("Training process interrupted")
+        raise TrainingTimeoutError, "Training process interrupted"
+      end
+    end
+
+    def cleanup(error_message)
+      return if @cleaned_up
+      @cleaned_up = true
+      @model.last_run.update(status: "failed", error_message: error_message, completed_at: Time.current)
+      @model.update(is_training: false)
+    end
+
+    def start_monitor_thread
+      Thread.new do
+        while true
+          puts "Monitoring activity... #{Time.current - @last_activity}"
+          if Time.current - @last_activity >= INACTIVITY_TIMEOUT
+            puts "Training process inactive for #{INACTIVITY_TIMEOUT} seconds, terminating..."
+            cleanup("Training process timed out")
+            Thread.main.raise(TrainingTimeoutError)
+            break
+          end
+          sleep 1
+        end
+      end
+    end
+  end
+end

data/app/models/easy_ml/adapters/base_adapter.rb

@@ -0,0 +1,45 @@
+module EasyML
+  module Adapters
+    class BaseAdapter
+      attr_reader :datasource
+
+      def initialize(datasource)
+        @datasource = datasource
+      end
+
+      def query(*)
+        raise NotImplementedError
+      end
+
+      def in_batches(*)
+        raise NotImplementedError
+      end
+
+      def files
+        raise NotImplementedError
+      end
+
+      def last_updated_at
+        raise NotImplementedError
+      end
+
+      def data
+        raise NotImplementedError
+      end
+
+      def needs_refresh?
+        false
+      end
+
+      def refresh
+        datasource.syncing do
+          # Default implementation does nothing
+        end
+      end
+
+      def refresh!
+        refresh
+      end
+    end
+  end
+end

data/app/models/easy_ml/adapters/polars_adapter.rb

@@ -0,0 +1,77 @@
+module EasyML
+  module Adapters
+    class PolarsAdapter < BaseAdapter
+      def initialize(datasource)
+        super
+        read_df_from_configuration
+      end
+
+      def query(drop_cols: [], filter: nil, limit: nil, select: nil, unique: nil, sort: nil, descending: false)
+        return if df.nil?
+
+        df = self.df.clone
+        df = df.filter(filter) if filter
+        df = df.select(select) if select.present?
+        df = df.unique if unique
+        drop_cols &= df.columns
+        df = df.drop(drop_cols) unless drop_cols.empty?
+        df = df.sort(sort, reverse: descending) if sort
+        df = df.limit(limit) if limit
+        df
+      end
+
+      def in_batches(of: 10_000)
+        total_rows = df.shape[0]
+        (0...total_rows).step(of) do |start|
+          end_index = [start + of, total_rows].min
+          yield df.slice(start, end_index - start)
+        end
+      end
+
+      def files
+        []
+      end
+
+      def last_updated_at
+        datasource.updated_at
+      end
+
+      def data
+        df
+      end
+
+      private
+
+      attr_accessor :df
+
+      def store_df_in_configuration
+        return unless df
+
+        datasource.configuration = (datasource.configuration || {}).merge(
+          "df" => JSON.parse(df.write_json)
+        )
+      end
+
+      def read_df_from_configuration
+        return unless datasource.configuration&.key?("df")
+
+        df_data = datasource.configuration["df"]
+        columns = df_data["columns"].map do |col|
+          dtype = case col["datatype"]
+                  when Hash
+                    if col["datatype"]["Datetime"]
+                      Polars::Datetime.new(col["datatype"]["Datetime"][0].downcase.to_sym).class
+                    else
+                      Polars::Utf8
+                    end
+                  else
+                    Polars.const_get(col["datatype"])
+                  end
+          Polars::Series.new(col["name"], col["values"], dtype: dtype)
+        end
+
+        @df = Polars::DataFrame.new(columns)
+      end
+    end
+  end
+end

data/app/models/easy_ml/cleaner.rb

@@ -0,0 +1,82 @@
+module EasyML
+  class Cleaner
+    attr_accessor :files_to_keep, :dirs_to_clean
+
+    def initialize(force: false, verbose: false)
+      @verbose = verbose
+      @files_to_keep = if force
+          []
+        else
+          model_files_to_keep +
+            dataset_files_to_keep +
+            datasource_files_to_keep
+        end
+    end
+
+    def self.clean(verbose: false)
+      new(verbose: verbose).clean
+    end
+
+    # Clean everything, including active models
+    def self.clean!(verbose: false)
+      new(force: true, verbose: verbose).clean
+    end
+
+    def clean
+      dirs_to_clean.each do |dir|
+        files_to_keep = files_to_keep_for_dir(dir)
+        EasyML::Support::FileRotate.new(dir, files_to_keep, verbose: @verbose).cleanup(%w[json parquet csv])
+      end
+    end
+
+    private
+
+    def files_to_keep_for_dir(dir)
+      files_to_keep.map(&:to_s).select { |f| f.start_with?(dir.to_s) }
+    end
+
+    def dirs_to_clean
+      %w[models datasets datasources].map do |dir|
+        EasyML::Engine.root_dir.join(dir)
+      end
+    end
+
+    def model_dirs
+      EasyML::Model.all.includes(dataset: :datasource).map do |model|
+        File.expand_path("..", model.root_dir)
+      end
+    end
+
+    def active_models
+      @active_models ||= begin
+          inference_models = EasyML::Model.deployed
+          training_models = EasyML::Model.all
+          (training_models + inference_models).compact
+        end
+    end
+
+    def model_files_to_keep
+      if Rails.env.test?
+        []
+      else
+        active_models.map(&:model_file).compact.map(&:full_path).uniq
+      end
+    end
+
+    def dataset_files_to_keep
+      if Rails.env.test?
+        []
+      else
+        EasyML::Dataset.all.flat_map(&:files).uniq
+      end
+    end
+
+    def datasource_files_to_keep
+      if Rails.env.test?
+        Dir.glob(EasyML::Engine.root_dir.glob("datasources/**/*.{csv,parquet}")).uniq
+      else
+        EasyML::Datasource.all.flat_map(&:files).uniq
+      end
+    end
+  end
+end

data/app/models/easy_ml/column.rb

@@ -0,0 +1,124 @@
+# == 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 Column < ActiveRecord::Base
+    self.table_name = "easy_ml_columns"
+    include Historiographer::Silent
+    historiographer_mode :snapshot_only
+
+    belongs_to :dataset, class_name: "EasyML::Dataset"
+
+    validates :name, presence: true
+    validates :name, uniqueness: { scope: :dataset_id }
+
+    before_save :ensure_valid_datatype
+
+    # Scopes
+    scope :visible, -> { where(hidden: false) }
+    scope :numeric, -> { where(datatype: %w[float integer]) }
+    scope :categorical, -> { where(datatype: %w[categorical string boolean]) }
+    scope :datetime, -> { where(datatype: "datetime") }
+
+    def datatype=(dtype)
+      write_attribute(:datatype, dtype)
+      write_attribute(:polars_datatype, dtype)
+    end
+
+    def get_polars_type(dtype)
+      EasyML::Data::PolarsColumn::TYPE_MAP[dtype.to_sym]
+    end
+
+    def polars_type
+      return nil if polars_datatype.blank?
+
+      get_polars_type(polars_datatype)
+    end
+
+    def polars_type=(dtype)
+      write_attribute(:polars_datatype, dtype.to_s)
+      write_attribute(:datatype, EasyML::Data::PolarsColumn::POLARS_MAP[type.class.to_s]&.to_s)
+    end
+
+    def preprocessing_steps=(steps)
+      return super({}) if steps.blank?
+
+      typed_steps = steps.transform_values do |config|
+        next config unless config[:params]&.key?(:constant)
+
+        config.deep_dup.tap do |c|
+          c[:params][:constant] = convert_to_type(c[:params][:constant])
+        end
+      end
+
+      super(typed_steps)
+    end
+
+    def preprocessing_steps
+      (read_attribute(:preprocessing_steps) || {}).symbolize_keys
+    end
+
+    def one_hot?
+      preprocessing_steps.deep_symbolize_keys.dig(:training, :params, :one_hot) == true
+    end
+
+    def ordinal_encoding?
+      preprocessing_steps.deep_symbolize_keys.dig(:training, :params, :ordinal_encoding) == true
+    end
+
+    def allowed_categories
+      return nil unless one_hot?
+
+      dataset.preprocessor.statistics.dup.to_h.dig(name.to_sym, :allowed_categories).sort.concat(["other"])
+    end
+
+    private
+
+    def ensure_valid_datatype
+      return if datatype.blank?
+
+      return if EasyML::Data::PolarsColumn::TYPE_MAP.key?(datatype.to_sym)
+
+      errors.add(:datatype, "must be one of: #{EasyML::Data::PolarsColumn::TYPE_MAP.keys.join(", ")}")
+      throw :abort
+    end
+
+    def convert_to_type(value)
+      return value if value.nil?
+
+      case datatype&.to_sym
+      when :float
+        Float(value)
+      when :integer
+        Integer(value)
+      when :boolean
+        ActiveModel::Type::Boolean.new.cast(value)
+      when :datetime
+        value.is_a?(String) ? Time.parse(value) : value
+      else
+        value.to_s
+      end
+    rescue ArgumentError, TypeError
+      # If conversion fails, return original value
+      value
+    end
+
+    NUMERIC_METHODS = %i[mean median].freeze
+  end
+end