easy_ml 0.2.0.pre.rc56 → 0.2.0.pre.rc58

data/app/models/easy_ml/model.rb

@@ -17,6 +17,7 @@
 #  is_training     :boolean
 #  created_at      :datetime         not null
 #  updated_at      :datetime         not null
+#  slug            :string           not null
 #
 require_relative "models/hyperparameters"
 
@@ -66,6 +67,7 @@ module EasyML
     after_initialize :bump_version, if: -> { new_record? }
     after_initialize :set_defaults, if: -> { new_record? }
     before_save :save_model_file, if: -> { is_fit? && !is_history_class? && model_changed? && !@skip_save_model_file }
+    before_validation :set_slug, if: :name_changed?
 
     VALID_TASKS = %i[regression classification].freeze
 
@@ -91,6 +93,7 @@ module EasyML
                      }
     validates :model_type, inclusion: { in: MODEL_NAMES }
     validates :dataset_id, presence: true
+    validates :slug, presence: true, uniqueness: true
     validate :validate_metrics_allowed
     before_save :set_root_dir
 
@@ -189,6 +192,7 @@ module EasyML
         evaluator: evaluator,
         model: self,
         dataset: dataset,
+        metrics: metrics,
       }.compact
       tuner.merge!(extra_params)
       tuner_instance = EasyML::Core::Tuner.new(tuner)
@@ -307,7 +311,6 @@ module EasyML
 
       dataset.refresh
       adapter.fit(tuning: tuning, x_train: x_train, y_train: y_train, x_valid: x_valid, y_valid: y_valid, &progress_block)
-      @is_fit = true
     end
 
     def batch_args
@@ -334,11 +337,8 @@ module EasyML
 
     def fit_in_batches(tuning: false, batch_size: nil, batch_overlap: nil, batch_key: nil, checkpoint_dir: Rails.root.join("tmp", "xgboost_checkpoints"), &progress_block)
       adapter.fit_in_batches(tuning: tuning, batch_size: batch_size, batch_overlap: batch_overlap, batch_key: batch_key, checkpoint_dir: checkpoint_dir, &progress_block)
-      @is_fit = true
     end
 
-    attr_accessor :is_fit
-
     def is_fit?
       model_file = get_model_file
       return true if model_file.present? && model_file.fit?
@@ -354,15 +354,16 @@ module EasyML
       dataset.decode_labels(ys, col: col)
     end
 
-    def evaluate(y_pred: nil, y_true: nil, x_true: nil, evaluator: nil)
+    def evaluate(y_pred: nil, y_true: nil, x_true: nil, evaluator: nil, dataset: nil)
       evaluator ||= self.evaluator
       if y_pred.nil?
         inputs = default_evaluation_inputs
         y_pred = inputs[:y_pred]
         y_true = inputs[:y_true]
         x_true = inputs[:x_true]
+        dataset = inputs[:dataset]
       end
-      EasyML::Core::ModelEvaluator.evaluate(model: self, y_pred: y_pred, y_true: y_true, x_true: x_true, evaluator: evaluator)
+      EasyML::Core::ModelEvaluator.evaluate(model: self, y_pred: y_pred, y_true: y_true, x_true: x_true, dataset: dataset, evaluator: evaluator)
     end
 
     def evaluator
@@ -446,6 +447,21 @@ module EasyML
       )
     end
 
+    include Rails.application.routes.mounted_helpers
+
+    def api_fields
+      {
+        url: EasyML::Engine.routes.url_helpers.predictions_path,
+        method: "POST",
+        data: {
+          model: slug,
+          input: dataset.columns.api_inputs.sort_by_required.map(&:to_api).each_with_object({}) do |field, hash|
+            hash[field[:name]] = field.except(:name)
+          end,
+        },
+      }
+    end
+
     class CannotdeployError < StandardError
     end
 
@@ -524,11 +540,13 @@ module EasyML
 
     def default_evaluation_inputs
       x_true, y_true = dataset.test(split_ys: true)
+      ds = dataset.test(all_columns: true)
       y_pred = predict(x_true)
       {
         x_true: x_true,
         y_true: y_true,
         y_pred: y_pred,
+        dataset: ds,
       }
     end
 
@@ -603,6 +621,12 @@ module EasyML
       errors.add(:metrics,
                  "don't know how to handle #{"metrics".pluralize(unknown_metrics)} #{unknown_metrics.join(", ")}, use EasyML::Core::ModelEvaluator.register(:name, Evaluator, :regression|:classification)")
     end
+
+    def set_slug
+      if slug.nil? && name.present?
+        self.slug = name.gsub(/\s/, "_").downcase
+      end
+    end
   end
 end
 

data/app/models/easy_ml/model_history.rb

@@ -22,6 +22,7 @@
 #  history_ended_at   :datetime
 #  history_user_id    :integer
 #  snapshot_id        :string
+#  slug               :string
 #
 module EasyML
   class ModelHistory < ActiveRecord::Base

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

@@ -32,7 +32,7 @@ module EasyML
           false
         end
 
-        def validation_dataset
+        def test_dataset
           if tuner.present?
             [tuner.x_true, tuner.y_true]
           else
@@ -46,11 +46,12 @@ module EasyML
           log_frequency = 10
           if epoch % log_frequency == 0
             model.adapter.external_model = booster
-            x_true, y_true = validation_dataset
+            x_true, y_true = test_dataset
             @preprocessed ||= model.preprocess(x_true)
             y_pred = model.predict(@preprocessed)
+            dataset = model.dataset.test(all_columns: true)
 
-            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, dataset: dataset)
             Wandb.log(metrics)
           end
 

data/app/models/easy_ml/retraining_run.rb

@@ -158,6 +158,7 @@ module EasyML
         model: training_model,
         y_pred: y_pred,
         y_true: y_true,
+        dataset: training_model.dataset.test(all_columns: true),
         evaluator: evaluator,
       )
       metric_value = metrics[metric]

data/config/initializers/inflections.rb

@@ -12,6 +12,8 @@ module EasyML
           inflect.acronym "EST"
           inflect.acronym "UTC"
           inflect.acronym "HTML"
+          inflect.acronym "API"
+          inflect.acronym "APIs"
         end
       end
     end

data/config/routes.rb

@@ -11,6 +11,9 @@ EasyML::Engine.routes.draw do
   # Predictions API
   resources :predictions, only: [:create]
 
+  # API Documentation
+  get "api", to: "apis#show"
+
   resources :models, as: :easy_ml_models do
     member do
       post :train

data/lib/easy_ml/core/evaluators/base_evaluator.rb

@@ -32,7 +32,7 @@ module EasyML
         end
 
         # Instance methods that evaluators must implement
-        def evaluate(y_pred: nil, y_true: nil, x_true: nil)
+        def evaluate(y_pred: nil, y_true: nil, x_true: nil, dataset: nil)
           raise NotImplementedError, "#{self.class} must implement #evaluate"
         end
 

data/lib/easy_ml/core/evaluators/classification_evaluators.rb

@@ -5,7 +5,7 @@ module EasyML
         class AccuracyScore
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             y_pred = Numo::Int32.cast(y_pred)
             y_true = Numo::Int32.cast(y_true)
             y_pred.eq(y_true).count_true.to_f / y_pred.size
@@ -23,7 +23,7 @@ module EasyML
         class PrecisionScore
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             y_pred = Numo::Int32.cast(y_pred)
             y_true = Numo::Int32.cast(y_true)
             true_positives = (y_pred.eq(1) & y_true.eq(1)).count_true
@@ -45,7 +45,7 @@ module EasyML
         class RecallScore
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             y_pred = Numo::Int32.cast(y_pred)
             y_true = Numo::Int32.cast(y_true)
             true_positives = (y_pred.eq(1) & y_true.eq(1)).count_true
@@ -65,9 +65,9 @@ module EasyML
         class F1Score
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
-            precision = PrecisionScore.new.evaluate(y_pred: y_pred, y_true: y_true)
-            recall = RecallScore.new.evaluate(y_pred: y_pred, y_true: y_true)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
+            precision = PrecisionScore.new.evaluate(y_pred: y_pred, y_true: y_true, dataset: dataset)
+            recall = RecallScore.new.evaluate(y_pred: y_pred, y_true: y_true, dataset: dataset)
             return 0 unless (precision + recall) > 0
 
             2 * (precision * recall) / (precision + recall)
@@ -85,7 +85,7 @@ module EasyML
         class AUC
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             y_pred = Numo::DFloat.cast(y_pred)
             y_true = Numo::Int32.cast(y_true)
 
@@ -132,8 +132,8 @@ module EasyML
         class ROC_AUC
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
-            AUC.new.evaluate(y_pred: y_pred, y_true: y_true)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
+            AUC.new.evaluate(y_pred: y_pred, y_true: y_true, dataset: dataset)
           end
 
           def description

data/lib/easy_ml/core/evaluators/regression_evaluators.rb

@@ -5,7 +5,7 @@ module EasyML
         class MeanAbsoluteError
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             (Numo::DFloat.cast(y_pred) - Numo::DFloat.cast(y_true)).abs.mean
           end
 
@@ -21,7 +21,7 @@ module EasyML
         class MeanSquaredError
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             ((Numo::DFloat.cast(y_pred) - Numo::DFloat.cast(y_true)) ** 2).mean
           end
 
@@ -37,7 +37,7 @@ module EasyML
         class RootMeanSquaredError
           include BaseEvaluator
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             Math.sqrt(((Numo::DFloat.cast(y_pred) - Numo::DFloat.cast(y_true)) ** 2).mean)
           end
 
@@ -61,7 +61,7 @@ module EasyML
             "maximize"
           end
 
-          def evaluate(y_pred:, y_true:, x_true: nil)
+          def evaluate(y_pred:, y_true:, x_true: nil, dataset: nil)
             y_true = Numo::DFloat.cast(y_true)
             y_pred = Numo::DFloat.cast(y_pred)
 

data/lib/easy_ml/core/model_evaluator.rb

@@ -98,13 +98,21 @@ module EasyML
           end
         end
 
-        def evaluate(model:, y_pred:, y_true:, x_true: nil, evaluator: nil)
+        def evaluate(model:, y_pred:, y_true:, x_true: nil, evaluator: nil, dataset: nil)
           y_pred = normalize_input(y_pred)
           y_true = normalize_input(y_true)
           check_size(y_pred, y_true)
 
           metrics_results = {}
 
+          if x_true.nil?
+            x_true = model.dataset.test
+          end
+
+          if dataset.nil?
+            dataset = model.dataset.test(all_columns: true)
+          end
+
           model.metrics.each do |metric|
             evaluator_class = get(metric.to_sym)
             next unless evaluator_class
@@ -115,6 +123,7 @@ module EasyML
               y_pred: y_pred,
               y_true: y_true,
               x_true: x_true,
+              dataset: dataset,
             )
           end
 
@@ -124,7 +133,7 @@ module EasyML
             raise "Unknown evaluator: #{evaluator}" unless evaluator_class
 
             evaluator_instance = evaluator_class.new
-            response = evaluator_instance.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true)
+            response = evaluator_instance.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true, dataset: dataset)
 
             if response.is_a?(Hash)
               metrics_results.merge!(response)
@@ -145,6 +154,9 @@ module EasyML
         def normalize_input(input)
           case input
           when Array
+            if input.first.class == TrueClass || input.first.class == FalseClass
+              input = input.map { |value| value ? 1.0 : 0.0 }
+            end
             Numo::DFloat.cast(input)
           when Polars::DataFrame
             if input.columns.count > 1
@@ -152,7 +164,10 @@ module EasyML
             end
 
             normalize_input(input[input.columns.first])
-          when Polars::Series, Array
+          when Polars::Series
+            if input.dtype == Polars::Boolean
+              input = input.cast(Polars::Int64)
+            end
             Numo::DFloat.cast(input)
           else
             raise ArgumentError, "Don't know how to evaluate model with y_pred type #{input.class}"

data/lib/easy_ml/core/tuner.rb

@@ -8,7 +8,7 @@ module EasyML
                     :metrics, :objective, :n_trials, :direction, :evaluator,
                     :study, :results, :adapter, :tune_started_at, :x_true, :y_true,
                     :project_name, :job, :current_run, :trial_enumerator, :progress_block,
-                    :tuner_job
+                    :tuner_job, :dataset
 
       def initialize(options = {})
         @model = options[:model]
@@ -77,6 +77,7 @@ module EasyML
         x_true, y_true = model.dataset.test(split_ys: true)
         self.x_true = x_true
         self.y_true = y_true
+        self.dataset = model.dataset.test(all_columns: true)
         adapter.tune_started_at = tune_started_at
         adapter.y_true = y_true
         adapter.x_true = x_true
@@ -96,14 +97,6 @@ module EasyML
             run_metrics = tune_once
             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(@current_trial, result)
           rescue StandardError => e
             @tuner_run.update!(status: :failed, hyperparameters: {})
@@ -138,14 +131,27 @@ module EasyML
         )
         self.current_run = @tuner_run
 
-        adapter.run_trial(@current_trial) do |model|
-          model.fit(tuning: true, &progress_block)
-          y_pred = model.predict(x_true)
-          model.metrics = metrics
-          metrics = model.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true)
-          puts metrics
-          metrics
+        model = adapter.run_trial(@current_trial) do |model|
+          model.tap do
+            model.fit(tuning: true, &progress_block)
+          end
         end
+
+        y_pred = model.predict(x_true)
+        model.metrics = metrics
+        metrics = model.evaluate(y_pred: y_pred, y_true: y_true, x_true: x_true, dataset: dataset)
+        metric = metrics.symbolize_keys.dig(model.evaluator[:metric].to_sym)
+
+        puts metrics
+
+        params = {
+          hyperparameters: model.hyperparameters.to_h,
+          value: metric,
+          status: :success,
+        }.compact
+
+        @tuner_run.update!(params)
+        metrics
       end
 
       private
@@ -167,7 +173,7 @@ module EasyML
         end
         raise ArgumentError, "Objectives required for EasyML::Core::Tuner" unless objective.present?
 
-        self.metrics = EasyML::Model.new(task: task).allowed_metrics if metrics.nil? || metrics.empty?
+        self.metrics = EasyML::Model.new(task: task).default_metrics if metrics.nil? || metrics.empty?
       end
     end
   end

data/lib/easy_ml/data/preprocessor.rb

@@ -90,46 +90,19 @@ module EasyML::Data
       df
     end
 
-    def learn_categorical_min(df, preprocessing_steps)
-      preprocessing_steps ||= {}
-      preprocessing_steps.deep_symbolize_keys!
-
-      allowed_categories = {}
-      (preprocessing_steps[:training] || {}).each_key do |col|
-        next unless [
-          preprocessing_steps.dig(:training, col, :params, :ordinal_encoding),
-          preprocessing_steps.dig(:training, col, :params, :one_hot),
-          preprocessing_steps.dig(:training, col, :method).to_sym == :categorical,
-        ].any?
-
-        cat_min = preprocessing_steps.dig(:training, col, :params, :categorical_min) || 1
-        val_counts = df[col].value_counts
-        allowed_categories[col] = val_counts[val_counts["count"] >= cat_min][col].to_a.compact
-      end
-      allowed_categories
-    end
-
-    def fit(df)
+    def fit(df, precomputed_stats = {})
       return if df.nil?
       return if preprocessing_steps.nil? || preprocessing_steps.keys.none?
 
       preprocessing_steps.deep_symbolize_keys!
       df = apply_clip(df, preprocessing_steps)
-      allowed_categories = learn_categorical_min(df, preprocessing_steps)
-
-      self.statistics = StatisticsLearner.learn_df(df, dataset: dataset).deep_symbolize_keys
 
-      # Merge allowed categories into statistics
-      allowed_categories.each do |col, categories|
-        statistics[col] ||= {}
-        statistics[col][:allowed_categories] = categories
-        statistics[col].merge!(
-          fit_categorical(df[col], preprocessing_steps)
-        )
-      end
+      self.statistics = StatisticsLearner.learn_df(df, dataset: dataset, type: :raw).deep_symbolize_keys.merge!(
+        precomputed_stats
+      ).deep_symbolize_keys
     end
 
-    def postprocess(df, inference: false)
+    def postprocess(df, inference: false, computed: false)
       puts "Postprocessing..." if verbose
       return df if preprocessing_steps.nil? || preprocessing_steps.keys.none?
 
@@ -139,6 +112,11 @@ module EasyML::Data
           preprocessing_steps[:training]
         end
 
+      if computed
+        computed_cols = dataset.columns.computed.map(&:name).map(&:to_sym)
+        steps = steps.deep_dup.slice(*computed_cols)
+      end
+
       df = apply_transformations(df, steps)
 
       puts "Postprocessing complete." if @verbose
@@ -260,27 +238,6 @@ module EasyML::Data
       )
     end
 
-    def fit_categorical(series, _preprocessing_steps)
-      value_counts = series.value_counts
-      column_names = value_counts.columns
-      value_column = column_names[0]
-      count_column = column_names[1]
-
-      as_hash = value_counts.select([value_column, count_column]).rows.to_a.to_h.transform_keys(&:to_s)
-      label_encoder = as_hash.keys.sort.each.with_index.reduce({}) do |h, (k, i)|
-        h.tap do
-          h[k] = i
-        end
-      end
-      label_decoder = label_encoder.invert
-
-      {
-        value: as_hash,
-        label_encoder: label_encoder,
-        label_decoder: label_decoder,
-      }
-    end
-
     def prepare_for_imputation(df, col)
       df = df.with_column(Polars.col(col).cast(Polars::Float64))
       df.with_column(Polars.when(Polars.col(col).is_null).then(Float::NAN).otherwise(Polars.col(col)).alias(col))

data/lib/easy_ml/data/splits/in_memory_split.rb

@@ -41,6 +41,10 @@ module EasyML
           split_features_targets(df, split_ys, target)
         end
 
+        def query(**kwargs)
+          read("all", **kwargs)
+        end
+
         def cleanup
           @data.clear
         end

data/lib/easy_ml/data/statistics_learner.rb

@@ -9,15 +9,16 @@ module EasyML::Data
       @verbose = options[:verbose]
     end
 
-    def self.learn(df, dataset = nil)
-      new(df, dataset).learn
+    def self.learn(df, dataset, type)
+      new(df, dataset, type).learn
     end
 
-    attr_reader :df, :dataset
+    attr_reader :df, :dataset, :type
 
-    def initialize(df, dataset)
+    def initialize(df, dataset, type)
       @df = df
       @dataset = dataset
+      @type = type.to_sym
     end
 
     def learn
@@ -27,18 +28,73 @@ module EasyML::Data
     def learn_split(split)
       df = split.read(:all)
       train_df = split.read(:train)
-      all_stats = learn_df(df, dataset: dataset)
-      train_stats = learn_df(train_df, dataset: dataset)
+      all_stats = learn_df(df)
+      train_stats = learn_df(train_df)
 
       all_stats.reduce({}) do |output, (k, _)|
         output.tap do
           output[k] = all_stats[k].slice(:num_rows, :null_count, :unique_count, :counts).merge!(
-            train_stats[k].slice(:mean, :median, :min, :max, :std, :last_value, :most_frequent_value, :last_known_value)
+            train_stats[k].slice(:mean, :median, :min, :max, :std,
+                                 :last_value, :most_frequent_value, :last_known_value,
+                                 :allowed_categories, :label_encoder, :label_decoder)
           )
         end
       end
     end
 
+    def learn_categorical(df)
+      allowed_categories = learn_allowed_categories(df)
+      allowed_categories.reduce({}) do |statistics, (col, categories)|
+        statistics.tap do
+          statistics[col] ||= {}
+          statistics[col][:allowed_categories] = categories
+          statistics[col].merge!(
+            learn_categorical_encoder_decoder(df[col])
+          )
+        end
+      end
+    end
+
+    def learn_categorical_encoder_decoder(series)
+      value_counts = series.value_counts
+      column_names = value_counts.columns
+      value_column = column_names[0]
+      count_column = column_names[1]
+
+      as_hash = value_counts.select([value_column, count_column]).rows.to_a.to_h.transform_keys(&:to_s)
+      label_encoder = as_hash.keys.sort.each.with_index.reduce({}) do |h, (k, i)|
+        h.tap do
+          h[k] = i
+        end
+      end
+      label_decoder = label_encoder.invert
+
+      {
+        value: as_hash,
+        label_encoder: label_encoder,
+        label_decoder: label_decoder,
+      }
+    end
+
+    def learn_allowed_categories(df)
+      preprocessing_steps = dataset.preprocessing_steps || {}
+      preprocessing_steps.deep_symbolize_keys!
+
+      allowed_categories = {}
+      (preprocessing_steps[:training] || {}).each_key do |col|
+        next unless [
+          preprocessing_steps.dig(:training, col, :params, :ordinal_encoding),
+          preprocessing_steps.dig(:training, col, :params, :one_hot),
+          preprocessing_steps.dig(:training, col, :method).to_sym == :categorical,
+        ].any?
+
+        cat_min = preprocessing_steps.dig(:training, col, :params, :categorical_min) || 1
+        val_counts = df[col].value_counts
+        allowed_categories[col] = val_counts[val_counts["count"] >= cat_min][col].to_a.compact
+      end
+      allowed_categories
+    end
+
     def last_known_value(df, col, date_col)
       return nil if df.empty? || !df.columns.include?(date_col)
 
@@ -53,13 +109,22 @@ module EasyML::Data
       last_value
     end
 
-    def learn_df(df, dataset: nil)
-      self.class.learn_df(df, dataset: dataset)
+    def learn_df(df)
+      return if df.nil?
+
+      stats = learn_base_stats(df, dataset: dataset).stringify_keys
+      if type == :raw
+        categorical = learn_categorical(df).stringify_keys
+        categorical.each { |k, v| stats[k].merge!(v) }
+      end
+      stats
     end
 
-    def self.learn_df(df, dataset: nil)
-      return if df.nil?
+    def self.learn_df(df, dataset: nil, type: :raw)
+      new(df, dataset, type).learn_df(df)
+    end
 
+    def learn_base_stats(df, dataset: nil)
       base_stats = describe_to_h(df).deep_symbolize_keys
 
       # Add basic column statistics first
@@ -103,16 +168,16 @@ module EasyML::Data
       end
     end
 
-    def self.id_column?(column)
+    def id_column?(column)
       col = column.to_s.downcase
       col.match?(/^id$/) || col.match?(/.*_id/)
     end
 
-    def self.last_value(df, col, date_col)
+    def last_value(df, col, date_col)
       df.filter(Polars.col(col).is_not_null).sort(date_col)[col][-1]
     end
 
-    def self.describe_to_h(df)
+    def describe_to_h(df)
       init_h = df.describe.to_h
       rows = init_h.values.map(&:to_a)
       keys = rows.first

data/lib/easy_ml/data/synced_directory.rb

@@ -127,8 +127,10 @@ module EasyML
         )
 
         Rails.logger.info("Downloaded #{object.key} to #{local_file_path}")
-        ungzipped_file_path = ungzip_file(local_file_path)
-        Rails.logger.info("Ungzipped to #{ungzipped_file_path}")
+        if object.key.end_with?(".gz")
+          ungzipped_file_path = ungzip_file(local_file_path)
+          Rails.logger.info("Ungzipped to #{ungzipped_file_path}")
+        end
       rescue Aws::S3::Errors::ServiceError, Net::OpenTimeout, Net::ReadTimeout, StandardError => e
         Rails.logger.error("Failed to process #{object.key}: #{e.message}")
         raise e