prophet-rb 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bcbd43f3750bc8c70fe28f2b0b42e88464724601daa754a9d60d8e8e354c701
-  data.tar.gz: c16f1ab7f2d48419543b54f326fc98ac1261c7e5ceaf7d3b0fd352b87a2fdcb3
+  metadata.gz: 69d58f060a9bda44b1ab8666ded81b3e61ff1b95b08ae40727fa7a2dfee57ee0
+  data.tar.gz: dc76685a8b45ca7cad79561f986af9c66e5e49bd45dd5e10c72f91088d9b470a
 SHA512:
-  metadata.gz: e8b3cf363a665f063d7045b3c34c124021281e063e61ff99e7bd98ba774a0e40a2d379aeb53f521833724b11d5ff1c7934820b73095ad5384b70066fc20e5e36
-  data.tar.gz: 177f8eab90b9be0e5112c3d158ef9b522309143c559a97ffa206b7cc63a83f0eb70e75d7e1f8ab9640e57e403bd85d1469ecdb9137b0be8acc03c7ff09a91447
+  metadata.gz: 34d2fd0587110c6de9db334c44a4859a5de92d1cc124efb5f865c845d504816f3d3cd34d63776a709de396af8f9b2cf82a390cfb9f3e49e685ef8be4f469fb3e
+  data.tar.gz: '0587986407bb68a9ca97928ad65bcbb42fe101bd9d2e50a44b2126df38d67c04544932ec39009c6f1d6467736aa0a8404ac4aad04187dcb953285d4d5ee80a77'

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.4.1 (2022-07-10)
+
+- Added support for cross validation and performance metrics
+- Added support for updating fitted models
+- Added support for saturating minimum forecasts
+
 ## 0.4.0 (2022-07-07)
 
 - Added support for saving and loading models

data/README.md

@@ -88,7 +88,8 @@ Check out the [Prophet documentation](https://facebook.github.io/prophet/docs/qu
 - [Multiplicative Seasonality](#multiplicative-seasonality)
 - [Uncertainty Intervals](#uncertainty-intervals)
 - [Non-Daily Data](#non-daily-data)
-- [Saving Models](#saving-models)
+- [Diagnostics](#diagnostics)
+- [Additional Topics](#additional-topics)
 
 ## Advanced Quick Start
 
@@ -177,11 +178,24 @@ df = Rover.read_csv("example_wp_log_R.csv")
 df["cap"] = 8.5
 m = Prophet.new(growth: "logistic")
 m.fit(df)
-future = m.make_future_dataframe(periods: 365)
+future = m.make_future_dataframe(periods: 1826)
 future["cap"] = 8.5
 forecast = m.predict(future)
 ```
 
+Saturating minimum
+
+```ruby
+df["y"] = 10 - df["y"]
+df["cap"] = 6
+df["floor"] = 1.5
+future["cap"] = 6
+future["floor"] = 1.5
+m = Prophet.new(growth: "logistic")
+m.fit(df)
+forecast = m.predict(future)
+```
+
 ## Trend Changepoints
 
 [Explanation](https://facebook.github.io/prophet/docs/trend_changepoints.html)
@@ -308,9 +322,64 @@ future = m.make_future_dataframe(periods: 300, freq: "H")
 forecast = m.predict(future)
 ```
 
-## Saving Models
+## Diagnostics
+
+[Explanation](http://facebook.github.io/prophet/docs/diagnostics.html)
+
+Cross validation
+
+```ruby
+df_cv = Prophet::Diagnostics.cross_validation(m, initial: "730 days", period: "180 days", horizon: "365 days")
+```
+
+Custom cutoffs
+
+```ruby
+cutoffs = ["2013-02-15", "2013-08-15", "2014-02-15"].map { |v| Time.parse("#{v} 00:00:00 UTC") }
+df_cv2 = Prophet::Diagnostics.cross_validation(m, cutoffs: cutoffs, horizon: "365 days")
+```
+
+Get performance metrics
 
-[Explanation](https://facebook.github.io/prophet/docs/additional_topics.html#saving-models)
+```ruby
+df_p = Prophet::Diagnostics.performance_metrics(df_cv)
+```
+
+Plot cross validation metrics
+
+```ruby
+Prophet::Plot.plot_cross_validation_metric(df_cv, metric: "mape")
+```
+
+Hyperparameter tuning
+
+```ruby
+param_grid = {
+  changepoint_prior_scale: [0.001, 0.01, 0.1, 0.5],
+  seasonality_prior_scale: [0.01, 0.1, 1.0, 10.0]
+}
+
+# Generate all combinations of parameters
+all_params = param_grid.values[0].product(*param_grid.values[1..-1]).map { |v| param_grid.keys.zip(v).to_h }
+rmses = [] # Store the RMSEs for each params here
+
+# Use cross validation to evaluate all parameters
+all_params.each do |params|
+  m = Prophet.new(**params).fit(df) # Fit model with given params
+  df_cv = Prophet::Diagnostics.cross_validation(m, cutoffs: cutoffs, horizon: "30 days")
+  df_p = Prophet::Diagnostics.performance_metrics(df_cv, rolling_window: 1)
+  rmses << df_p["rmse"][0]
+end
+
+# Find the best parameters
+tuning_results = Rover::DataFrame.new(all_params)
+tuning_results["rmse"] = rmses
+p tuning_results
+```
+
+## Additional Topics
+
+[Explanation](https://facebook.github.io/prophet/docs/additional_topics.html)
 
 Save a model
 
@@ -326,6 +395,34 @@ m = Prophet.from_json(File.read("model.json"))
 
 Uses the same format as Python, so models can be saved and loaded in either language
 
+Flat trend
+
+```ruby
+m = Prophet.new(growth: "flat")
+```
+
+Updating fitted models
+
+```ruby
+def stan_init(m)
+  res = {}
+  ["k", "m", "sigma_obs"].each do |pname|
+    res[pname] = m.params[pname][0, true][0]
+  end
+  ["delta", "beta"].each do |pname|
+    res[pname] = m.params[pname][0, true]
+  end
+  res
+end
+
+df = Rover.read_csv("example_wp_log_peyton_manning.csv")
+df1 = df[df["ds"] <= "2016-01-19"] # All data except the last day
+m1 = Prophet.new.fit(df1) # A model fit to all data except the last day
+
+m2 = Prophet.new.fit(df) # Adding the last day, fitting from scratch
+m2 = Prophet.new.fit(df, init: stan_init(m1)) # Adding the last day, warm-starting from m1
+```
+
 ## Resources
 
 - [Forecasting at Scale](https://peerj.com/preprints/3190.pdf)

data/lib/prophet/diagnostics.rb

@@ -0,0 +1,349 @@
+module Prophet
+  module Diagnostics
+    def self.generate_cutoffs(df, horizon, initial, period)
+      # Last cutoff is 'latest date in data - horizon' date
+      cutoff = df["ds"].max - horizon
+      if cutoff < df["ds"].min
+        raise Error, "Less data than horizon."
+      end
+      result = [cutoff]
+      while result[-1] >= df["ds"].min + initial
+        cutoff -= period
+        # If data does not exist in data range (cutoff, cutoff + horizon]
+        if !(((df["ds"] > cutoff) & (df["ds"] <= cutoff + horizon)).any?)
+          # Next cutoff point is 'last date before cutoff in data - horizon'
+          if cutoff > df["ds"].min
+            closest_date = df[df["ds"] <= cutoff].max["ds"]
+            cutoff = closest_date - horizon
+          end
+          # else no data left, leave cutoff as is, it will be dropped.
+        end
+        result << cutoff
+      end
+      result = result[0...-1]
+      if result.length == 0
+        raise Error, "Less data than horizon after initial window. Make horizon or initial shorter."
+      end
+      # logger.info("Making #{result.length} forecasts with cutoffs between #{result[-1]} and #{result[0]}")
+      result.reverse
+    end
+
+    def self.cross_validation(model, horizon:, period: nil, initial: nil, cutoffs: nil)
+      if model.history.nil?
+        raise Error, "Model has not been fit. Fitting the model provides contextual parameters for cross validation."
+      end
+
+      df = model.history.dup
+      horizon = timedelta(horizon)
+
+      predict_columns = ["ds", "yhat"]
+      if model.uncertainty_samples
+        predict_columns.concat(["yhat_lower", "yhat_upper"])
+      end
+
+      # Identify largest seasonality period
+      period_max = 0.0
+      model.seasonalities.each do |_, s|
+        period_max = [period_max, s[:period]].max
+      end
+      seasonality_dt = timedelta("#{period_max} days")
+
+      if cutoffs.nil?
+        # Set period
+        period = period.nil? ? 0.5 * horizon : timedelta(period)
+
+        # Set initial
+        initial = initial.nil? ? [3 * horizon, seasonality_dt].max : timedelta(initial)
+
+        # Compute Cutoffs
+        cutoffs = generate_cutoffs(df, horizon, initial, period)
+      else
+        # add validation of the cutoff to make sure that the min cutoff is strictly greater than the min date in the history
+        if cutoffs.min <= df["ds"].min
+          raise Error, "Minimum cutoff value is not strictly greater than min date in history"
+        end
+        # max value of cutoffs is <= (end date minus horizon)
+        end_date_minus_horizon = df["ds"].max - horizon
+        if cutoffs.max > end_date_minus_horizon
+          raise Error, "Maximum cutoff value is greater than end date minus horizon, no value for cross-validation remaining"
+        end
+        initial = cutoffs[0] - df["ds"].min
+      end
+
+      # Check if the initial window
+      # (that is, the amount of time between the start of the history and the first cutoff)
+      # is less than the maximum seasonality period
+      if initial < seasonality_dt
+        msg = "Seasonality has period of #{period_max} days "
+        msg += "which is larger than initial window. "
+        msg += "Consider increasing initial."
+        # logger.warn(msg)
+      end
+
+      predicts = cutoffs.map { |cutoff| single_cutoff_forecast(df, model, cutoff, horizon, predict_columns) }
+
+      # Combine all predicted DataFrame into one DataFrame
+      predicts.reduce(Rover::DataFrame.new) { |memo, v| memo.concat(v) }
+    end
+
+    def self.single_cutoff_forecast(df, model, cutoff, horizon, predict_columns)
+      # Generate new object with copying fitting options
+      m = prophet_copy(model, cutoff)
+      # Train model
+      history_c = df[df["ds"] <= cutoff]
+      if history_c.shape[0] < 2
+        raise Error, "Less than two datapoints before cutoff. Increase initial window."
+      end
+      m.fit(history_c, **model.fit_kwargs)
+      # Calculate yhat
+      index_predicted = (df["ds"] > cutoff) & (df["ds"] <= cutoff + horizon)
+      # Get the columns for the future dataframe
+      columns = ["ds"]
+      if m.growth == "logistic"
+        columns << "cap"
+        if m.logistic_floor
+          columns << "floor"
+        end
+      end
+      columns.concat(m.extra_regressors.keys)
+      columns.concat(m.seasonalities.map { |_, props| props[:condition_name] }.compact)
+      yhat = m.predict(df[index_predicted][columns])
+      # Merge yhat(predicts), y(df, original data) and cutoff
+      yhat[predict_columns].merge(df[index_predicted][["y"]]).merge(Rover::DataFrame.new({"cutoff" => [cutoff] * yhat.length}))
+    end
+
+    def self.prophet_copy(m, cutoff = nil)
+      if m.history.nil?
+        raise Error, "This is for copying a fitted Prophet object."
+      end
+
+      if m.specified_changepoints
+        changepoints = m.changepoints
+        if !cutoff.nil?
+          # Filter change points '< cutoff'
+          last_history_date = m.history["ds"][m.history["ds"] <= cutoff].max
+          changepoints = changepoints[changepoints < last_history_date]
+        end
+      else
+        changepoints = nil
+      end
+
+      # Auto seasonalities are set to False because they are already set in
+      # m.seasonalities.
+      m2 = m.class.new(
+        growth: m.growth,
+        n_changepoints: m.n_changepoints,
+        changepoint_range: m.changepoint_range,
+        changepoints: changepoints,
+        yearly_seasonality: false,
+        weekly_seasonality: false,
+        daily_seasonality: false,
+        holidays: m.holidays,
+        seasonality_mode: m.seasonality_mode,
+        seasonality_prior_scale: m.seasonality_prior_scale,
+        changepoint_prior_scale: m.changepoint_prior_scale,
+        holidays_prior_scale: m.holidays_prior_scale,
+        mcmc_samples: m.mcmc_samples,
+        interval_width: m.interval_width,
+        uncertainty_samples: m.uncertainty_samples
+      )
+      m2.extra_regressors = deepcopy(m.extra_regressors)
+      m2.seasonalities = deepcopy(m.seasonalities)
+      m2.country_holidays = deepcopy(m.country_holidays)
+      m2
+    end
+
+    def self.timedelta(value)
+      if value.is_a?(Numeric)
+        # ActiveSupport::Duration is a numeric
+        value
+      elsif (m = /\A(\d+(\.\d+)?) days\z/.match(value))
+        m[1].to_f * 86400
+      else
+        raise Error, "Unknown time delta"
+      end
+    end
+
+    def self.deepcopy(value)
+      if value.is_a?(Hash)
+        value.to_h { |k, v| [deepcopy(k), deepcopy(v)] }
+      elsif value.is_a?(Array)
+        value.map { |v| deepcopy(v) }
+      else
+        value.dup
+      end
+    end
+
+    def self.performance_metrics(df, metrics: nil, rolling_window: 0.1, monthly: false)
+      valid_metrics = ["mse", "rmse", "mae", "mape", "mdape", "smape", "coverage"]
+      if metrics.nil?
+        metrics = valid_metrics
+      end
+      if (df["yhat_lower"].nil? || df["yhat_upper"].nil?) && metrics.include?("coverage")
+        metrics.delete("coverage")
+      end
+      if metrics.uniq.length != metrics.length
+        raise ArgumentError, "Input metrics must be a list of unique values"
+      end
+      if !Set.new(metrics).subset?(Set.new(valid_metrics))
+        raise ArgumentError, "Valid values for metrics are: #{valid_metrics}"
+      end
+      df_m = df.dup
+      if monthly
+        raise Error, "Not implemented yet"
+        # df_m["horizon"] = df_m["ds"].dt.to_period("M").astype(int) - df_m["cutoff"].dt.to_period("M").astype(int)
+      else
+        df_m["horizon"] = df_m["ds"] - df_m["cutoff"]
+      end
+      df_m.sort_by! { |r| r["horizon"] }
+      if metrics.include?("mape") && df_m["y"].abs.min < 1e-8
+        # logger.info("Skipping MAPE because y close to 0")
+        metrics.delete("mape")
+      end
+      if metrics.length == 0
+        return nil
+      end
+      w = (rolling_window * df_m.shape[0]).to_i
+      if w >= 0
+        w = [w, 1].max
+        w = [w, df_m.shape[0]].min
+      end
+      # Compute all metrics
+      dfs = {}
+      metrics.each do |metric|
+        dfs[metric] = send(metric, df_m, w)
+      end
+      res = dfs[metrics[0]]
+      metrics.each do |metric|
+        res_m = dfs[metric]
+        res[metric] = res_m[metric]
+      end
+      res
+    end
+
+    def self.rolling_mean_by_h(x, h, w, name)
+      # Aggregate over h
+      df = Rover::DataFrame.new({"x" => x, "h" => h})
+      df2 = df.group("h").sum("x").inner_join(df.group("h").count).sort_by { |r| r["h"] }
+      xs = df2["sum_x"]
+      ns = df2["count"]
+      hs = df2["h"]
+
+      trailing_i = df2.length - 1
+      x_sum = 0
+      n_sum = 0
+      # We don't know output size but it is bounded by len(df2)
+      res_x = [nil] * df2.length
+
+      # Start from the right and work backwards
+      (df2.length - 1).downto(0) do |i|
+        x_sum += xs[i]
+        n_sum += ns[i]
+        while n_sum >= w
+          # Include points from the previous horizon. All of them if still
+          # less than w, otherwise weight the mean by the difference
+          excess_n = n_sum - w
+          excess_x = excess_n * xs[i] / ns[i]
+          res_x[trailing_i] = (x_sum - excess_x) / w
+          x_sum -= xs[trailing_i]
+          n_sum -= ns[trailing_i]
+          trailing_i -= 1
+        end
+      end
+
+      res_h = hs[(trailing_i + 1)..-1]
+      res_x = res_x[(trailing_i + 1)..-1]
+
+      Rover::DataFrame.new({"horizon" => res_h, name => res_x})
+    end
+
+    def self.rolling_median_by_h(x, h, w, name)
+      # Aggregate over h
+      df = Rover::DataFrame.new({"x" => x, "h" => h})
+      grouped = df.group("h")
+      df2 = grouped.count.sort_by { |r| r["h"] }
+      hs = df2["h"]
+
+      res_h = []
+      res_x = []
+      # Start from the right and work backwards
+      i = hs.length - 1
+      while i >= 0
+        h_i = hs[i]
+        xs = df[df["h"] == h_i]["x"].to_a
+
+        next_idx_to_add = (h == h_i).to_numo.cast_to(Numo::UInt8).argmax - 1
+        while xs.length < w && next_idx_to_add >= 0
+          # Include points from the previous horizon. All of them if still
+          # less than w, otherwise just enough to get to w.
+          xs << x[next_idx_to_add]
+          next_idx_to_add -= 1
+        end
+        if xs.length < w
+          # Ran out of points before getting enough.
+          break
+        end
+        res_h << hs[i]
+        res_x << Rover::Vector.new(xs).median
+        i -= 1
+      end
+      res_h.reverse!
+      res_x.reverse!
+      Rover::DataFrame.new({"horizon" => res_h, name => res_x})
+    end
+
+    def self.mse(df, w)
+      se = (df["y"] - df["yhat"]) ** 2
+      if w < 0
+        return Rover::DataFrame.new({"horizon" => df["horizon"], "mse" => se})
+      end
+      rolling_mean_by_h(se, df["horizon"], w, "mse")
+    end
+
+    def self.rmse(df, w)
+      res = mse(df, w)
+      res["rmse"] = res.delete("mse").map { |v| Math.sqrt(v) }
+      res
+    end
+
+    def self.mae(df, w)
+      ae = (df["y"] - df["yhat"]).abs
+      if w < 0
+        return Rover::DataFrame.new({"horizon" => df["horizon"], "mae" => ae})
+      end
+      rolling_mean_by_h(ae, df["horizon"], w, "mae")
+    end
+
+    def self.mape(df, w)
+      ape = ((df["y"] - df["yhat"]) / df["y"]).abs
+      if w < 0
+        return Rover::DataFrame.new({"horizon" => df["horizon"], "mape" => ape})
+      end
+      rolling_mean_by_h(ape, df["horizon"], w, "mape")
+    end
+
+    def self.mdape(df, w)
+      ape = ((df["y"] - df["yhat"]) / df["y"]).abs
+      if w < 0
+        return Rover::DataFrame.new({"horizon" => df["horizon"], "mdape" => ape})
+      end
+      rolling_median_by_h(ape, df["horizon"], w, "mdape")
+    end
+
+    def self.smape(df, w)
+      sape = (df["y"] - df["yhat"]).abs / ((df["y"].abs + df["yhat"].abs) / 2)
+      if w < 0
+        return Rover::DataFrame.new({"horizon" => df["horizon"], "smape" => sape})
+      end
+      rolling_mean_by_h(sape, df["horizon"], w, "smape")
+    end
+
+    def self.coverage(df, w)
+      is_covered = (df["y"] >= df["yhat_lower"]) & (df["y"] <= df["yhat_upper"])
+      if w < 0
+        return Rover::DataFrame.new({"horizon" => df["horizon"], "coverage" => is_covered})
+      end
+      rolling_mean_by_h(is_covered.to(:float), df["horizon"], w, "coverage")
+    end
+  end
+end

data/lib/prophet/forecaster.rb

@@ -3,7 +3,14 @@ module Prophet
     include Holidays
     include Plot
 
-    attr_reader :logger, :params, :train_holiday_names
+    attr_reader :logger, :params, :train_holiday_names,
+      :history, :seasonalities, :specified_changepoints, :fit_kwargs,
+      :growth, :changepoints, :n_changepoints, :changepoint_range,
+      :holidays, :seasonality_mode, :seasonality_prior_scale,
+      :holidays_prior_scale, :changepoint_prior_scale, :mcmc_samples,
+      :interval_width, :uncertainty_samples
+
+    attr_accessor :extra_regressors, :seasonalities, :country_holidays
 
     def initialize(
       growth: "linear",
@@ -176,8 +183,10 @@ module Prophet
 
       initialize_scales(initialize_scales, df)
 
-      if @logistic_floor && !df.include?("floor")
-        raise ArgumentError, "Expected column \"floor\"."
+      if @logistic_floor
+        unless df.include?("floor")
+          raise ArgumentError, "Expected column \"floor\"."
+        end
       else
         df["floor"] = 0
       end
@@ -207,7 +216,12 @@ module Prophet
     def initialize_scales(initialize_scales, df)
       return unless initialize_scales
 
-      floor = 0
+      if @growth == "logistic" && df.include?("floor")
+        @logistic_floor = true
+        floor = df["floor"]
+      else
+        floor = 0.0
+      end
       @y_scale = (df["y"] - floor).abs.max
       @y_scale = 1 if @y_scale == 0
       @start = df["ds"].min

data/lib/prophet/plot.rb

@@ -111,6 +111,61 @@ module Prophet
       artists
     end
 
+    def self.plot_cross_validation_metric(df_cv, metric:, rolling_window: 0.1, ax: nil, figsize: [10, 6], color: "b", point_color: "gray")
+      if ax.nil?
+        fig = plt.figure(facecolor: "w", figsize: figsize)
+        ax = fig.add_subplot(111)
+      else
+        fig = ax.get_figure
+      end
+      # Get the metric at the level of individual predictions, and with the rolling window.
+      df_none = Diagnostics.performance_metrics(df_cv, metrics: [metric], rolling_window: -1)
+      df_h = Diagnostics.performance_metrics(df_cv, metrics: [metric], rolling_window: rolling_window)
+
+      # Some work because matplotlib does not handle timedelta
+      # Target ~10 ticks.
+      tick_w = df_none["horizon"].max * 1e9 / 10.0
+      # Find the largest time resolution that has <1 unit per bin.
+      dts = ["D", "h", "m", "s", "ms", "us", "ns"]
+      dt_names = ["days", "hours", "minutes", "seconds", "milliseconds", "microseconds", "nanoseconds"]
+      dt_conversions = [
+        24 * 60 * 60 * 10 ** 9,
+        60 * 60 * 10 ** 9,
+        60 * 10 ** 9,
+        10 ** 9,
+        10 ** 6,
+        10 ** 3,
+        1.0
+      ]
+      # TODO update
+      i = 0
+      # dts.each_with_index do |dt, i|
+      #   if np.timedelta64(1, dt) < np.timedelta64(tick_w, "ns")
+      #     break
+      #   end
+      # end
+
+      x_plt = df_none["horizon"] * 1e9 / dt_conversions[i].to_f
+      x_plt_h = df_h["horizon"] * 1e9 / dt_conversions[i].to_f
+
+      ax.plot(x_plt.to_a, df_none[metric].to_a, ".", alpha: 0.1, c: point_color)
+      ax.plot(x_plt_h.to_a, df_h[metric].to_a, "-", c: color)
+      ax.grid(true)
+
+      ax.set_xlabel("Horizon (#{dt_names[i]})")
+      ax.set_ylabel(metric)
+      fig
+    end
+
+    def self.plt
+      begin
+        require "matplotlib/pyplot"
+      rescue LoadError
+        raise Error, "Install the matplotlib gem for plots"
+      end
+      Matplotlib::Pyplot
+    end
+
     private
 
     def plot_forecast_component(fcst, name, ax: nil, uncertainty: true, plot_cap: false, figsize: [10, 6])
@@ -263,12 +318,7 @@ module Prophet
     end
 
     def plt
-      begin
-        require "matplotlib/pyplot"
-      rescue LoadError
-        raise Error, "Install the matplotlib gem for plots"
-      end
-      Matplotlib::Pyplot
+      Plot.plt
     end
 
     def dates

data/lib/prophet/stan_backend.rb

@@ -13,6 +13,11 @@ module Prophet
 
     def fit(stan_init, stan_data, **kwargs)
       stan_init, stan_data = prepare_data(stan_init, stan_data)
+
+      if !kwargs[:inits] && kwargs[:init]
+        kwargs[:inits] = prepare_data(kwargs.delete(:init), stan_data)[0]
+      end
+
       kwargs[:algorithm] ||= stan_data["T"] < 100 ? "Newton" : "LBFGS"
       iterations = 10000
 
@@ -49,6 +54,10 @@ module Prophet
     def sampling(stan_init, stan_data, samples, **kwargs)
       stan_init, stan_data = prepare_data(stan_init, stan_data)
 
+      if !kwargs[:inits] && kwargs[:init]
+        kwargs[:inits] = prepare_data(kwargs.delete(:init), stan_data)[0]
+      end
+
       kwargs[:chains] ||= 4
       kwargs[:warmup_iters] ||= samples / 2
 
@@ -128,7 +137,7 @@ module Prophet
       stan_data["t_change"] = stan_data["t_change"].to_a
       stan_data["s_a"] = stan_data["s_a"].to_a
       stan_data["s_m"] = stan_data["s_m"].to_a
-      stan_data["X"] = stan_data["X"].to_numo.to_a
+      stan_data["X"] = stan_data["X"].respond_to?(:to_numo) ? stan_data["X"].to_numo.to_a : stan_data["X"].to_a
       stan_init["delta"] = stan_init["delta"].to_a
       stan_init["beta"] = stan_init["beta"].to_a
       [stan_init, stan_data]

data/lib/prophet/version.rb

@@ -1,3 +1,3 @@
 module Prophet
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/lib/prophet.rb

@@ -8,6 +8,7 @@ require "logger"
 require "set"
 
 # modules
+require "prophet/diagnostics"
 require "prophet/holidays"
 require "prophet/plot"
 require "prophet/forecaster"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prophet-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-07 00:00:00.000000000 Z
+date: 2022-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdstan
@@ -66,6 +66,7 @@ files:
 - data-raw/generated_holidays.csv
 - lib/prophet-rb.rb
 - lib/prophet.rb
+- lib/prophet/diagnostics.rb
 - lib/prophet/forecaster.rb
 - lib/prophet/holidays.rb
 - lib/prophet/plot.rb