prophet-rb 0.1.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8cdf7fd6b309bc24d83bb12e4ad87ba1ba36ba0c6abc803485f11a5718ab649
-  data.tar.gz: d63c201452d57ef99349f3bf8b51249863cadbc555daef6a1f122d2ede571fdb
+  metadata.gz: 756e42a4e2c39e114610d2f41e2403d9b160e77da02c0483e43b4bf460dd828b
+  data.tar.gz: e7bce55f47410227131afcba9d2f90c9812dab093efd1c17465383b3a5e6dc73
 SHA512:
-  metadata.gz: 81991c4edf0fa86d34e876ff8ebf2344491ae10dde95d736bbae3987592e7d419dc5167bf2b390eec19a88700152fff8c8f7eadb18f2d81fcfa928c9172c1ee8
-  data.tar.gz: 17e146ec6c6f74c792ac6da8bcd1103ad34df8303c7c76961ef956fcdbd0b343f14ff6a97ec4774c4d813dcfd07f5c3a1404365f24f27a636450f2bed9e895b0
+  metadata.gz: ec014f32ff39abd49195d7e9a7f38b3b297bc7f6fc28da3d1be6fb19b6edbe816a681c4fbb35d5ea79fc2ced0aa948b0468cff9f6d9d8293590761711944b71b
+  data.tar.gz: 87ecc8706c73e7f1063c8d75cc5c687ebc3fddb92d89e60bb115d21c90a60fbb6172648a0d414baeb11f04572b37e06777d4100acb07b8559dea8e8a711741fb

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.2.3 (2020-10-14)
+
+- Added support for times to `forecast` method
+
+## 0.2.2 (2020-07-26)
+
+- Fixed error with constant series
+- Fixed error with no changepoints
+
+## 0.2.1 (2020-07-15)
+
+- Added `forecast` method
+
+## 0.2.0 (2020-05-13)
+
+- Switched from Daru to Rover
+
+## 0.1.1 (2020-04-10)
+
+- Added `add_changepoints_to_plot`
+- Fixed error with `changepoints` option
+- Fixed error with `mcmc_samples` option
+- Fixed error with additional regressors
+
 ## 0.1.0 (2020-04-09)
 
 - First release

data/LICENSE.txt

@@ -1,7 +1,7 @@
 MIT License
 
-Copyright (c) 2020 Andrew Kane
 Copyright (c) Facebook, Inc. and its affiliates.
+Copyright (c) 2020 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -10,6 +10,8 @@ Supports:
 
 And gracefully handles missing data
 
+[![Build Status](https://travis-ci.org/ankane/prophet.svg?branch=master)](https://travis-ci.org/ankane/prophet) [![Build status](https://ci.appveyor.com/api/projects/status/8ahmsvvhum4ivnmv/branch/master?svg=true)](https://ci.appveyor.com/project/ankane/prophet/branch/master)
+
 ## Installation
 
 Add this line to your application’s Gemfile:
@@ -18,19 +20,47 @@ Add this line to your application’s Gemfile:
 gem 'prophet-rb'
 ```
 
-## Documentation
+## Simple API
+
+Get future predictions for a time series
+
+```ruby
+series = {
+  Date.parse("2020-01-01") => 100,
+  Date.parse("2020-01-02") => 150,
+  Date.parse("2020-01-03") => 136,
+  # ...
+}
+
+Prophet.forecast(series)
+```
+
+Specify the number of predictions to return
+
+```ruby
+Prophet.forecast(series, count: 3)
+```
+
+Works great with [Groupdate](https://github.com/ankane/groupdate)
+
+```ruby
+series = User.group_by_day(:created_at).count
+Prophet.forecast(series)
+```
+
+## Advanced API
 
-Check out the [Prophet documentation](https://facebook.github.io/prophet/docs/quick_start.html) for a great explanation of all of the features. The Ruby API follows the Python API and supports the same features.
+Check out the [Prophet documentation](https://facebook.github.io/prophet/docs/quick_start.html) for a great explanation of all of the features. The advanced API follows the Python API and supports the same features. It uses [Rover](https://github.com/ankane/rover) for data frames.
 
-## Quick Start
+## Advanced Quick Start
 
 [Explanation](https://facebook.github.io/prophet/docs/quick_start.html)
 
 Create a data frame with `ds` and `y` columns - here’s [an example](examples/example_wp_log_peyton_manning.csv) you can use
 
 ```ruby
-df = Daru::DataFrame.from_csv("example_wp_log_peyton_manning.csv")
-df.head(5)
+df = Rover.read_csv("example_wp_log_peyton_manning.csv")
+df.head
 ```
 
 ds | y
@@ -52,7 +82,7 @@ Make a data frame with a `ds` column for future predictions
 
 ```ruby
 future = m.make_future_dataframe(periods: 365)
-future.tail(5)
+future.tail
 ```
 
 ds |
@@ -67,7 +97,7 @@ Make predictions
 
 ```ruby
 forecast = m.predict(future)
-forecast["ds", "yhat", "yhat_lower", "yhat_upper"].tail(5)
+forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].tail
 ```
 
 ds | yhat | yhat_lower | yhat_upper
@@ -88,7 +118,7 @@ Plot the forecast
 m.plot(forecast).savefig("forecast.png")
 ```
 
-![Forecast](https://blazer.dokkuapp.com/assets/prophet/forecast-a9d43195b8ad23703eda7bb8b52b8a758efb4699e2313f32d7bbdfaa2f4275f6.png)
+![Forecast](https://blazer.dokkuapp.com/assets/prophet/forecast-77cf453fda67d1b462c6c22aee3a02572203b71c4517fedecc1f438cd374a876.png)
 
 Plot components
 
@@ -96,7 +126,46 @@ Plot components
 m.plot_components(forecast).savefig("components.png")
 ```
 
-![Components](https://blazer.dokkuapp.com/assets/prophet/components-b9e31bfcf77e57bbd503c0bcff5e5544e66085b90709b06dd96c5f622a87d84f.png)
+![Components](https://blazer.dokkuapp.com/assets/prophet/components-2cdd260e23bc89824ecca25f6bfe394deb5821d60b7e0e551469c90d204acd67.png)
+
+## Saturating Forecasts
+
+[Explanation](https://facebook.github.io/prophet/docs/saturating_forecasts.html)
+
+Forecast logistic growth instead of linear
+
+```ruby
+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["cap"] = 8.5
+forecast = m.predict(future)
+```
+
+## Trend Changepoints
+
+[Explanation](https://facebook.github.io/prophet/docs/trend_changepoints.html)
+
+Plot changepoints
+
+```ruby
+fig = m.plot(forecast)
+m.add_changepoints_to_plot(fig.gca, forecast)
+```
+
+Adjust trend flexibility
+
+```ruby
+m = Prophet.new(changepoint_prior_scale: 0.5)
+```
+
+Specify the location of changepoints
+
+```ruby
+m = Prophet.new(changepoints: ["2014-01-01"])
+```
 
 ## Holidays and Special Events
 
@@ -105,21 +174,21 @@ m.plot_components(forecast).savefig("components.png")
 Create a data frame with `holiday` and `ds` columns. Include all occurrences in your past data and future occurrences you’d like to forecast.
 
 ```ruby
-playoffs = Daru::DataFrame.new(
-  "holiday" => ["playoff"] * 14,
+playoffs = Rover::DataFrame.new(
+  "holiday" => "playoff",
   "ds" => ["2008-01-13", "2009-01-03", "2010-01-16",
            "2010-01-24", "2010-02-07", "2011-01-08",
            "2013-01-12", "2014-01-12", "2014-01-19",
            "2014-02-02", "2015-01-11", "2016-01-17",
            "2016-01-24", "2016-02-07"],
-  "lower_window" => [0] * 14,
-  "upper_window" => [1] * 14
+  "lower_window" => 0,
+  "upper_window" => 1
 )
-superbowls = Daru::DataFrame.new(
-  "holiday" => ["superbowl"] * 3,
+superbowls = Rover::DataFrame.new(
+  "holiday" => "superbowl",
   "ds" => ["2010-02-07", "2014-02-02", "2016-02-07"],
-  "lower_window" => [0] * 3,
-  "upper_window" => [1] * 3
+  "lower_window" => 0,
+  "upper_window" => 1
 )
 holidays = playoffs.concat(superbowls)
 
@@ -141,7 +210,25 @@ Specify custom seasonalities
 m = Prophet.new(weekly_seasonality: false)
 m.add_seasonality(name: "monthly", period: 30.5, fourier_order: 5)
 forecast = m.fit(df).predict(future)
-m.plot_components(forecast).savefig("components.png")
+```
+
+Specify additional regressors
+
+```ruby
+nfl_sunday = lambda do |ds|
+  date = ds.respond_to?(:to_date) ? ds.to_date : Date.parse(ds)
+  date.wday == 0 && (date.month > 8 || date.month < 2) ? 1 : 0
+end
+
+df["nfl_sunday"] = df["ds"].map(&nfl_sunday)
+
+m = Prophet.new
+m.add_regressor("nfl_sunday")
+m.fit(df)
+
+future["nfl_sunday"] = future["ds"].map(&nfl_sunday)
+
+forecast = m.predict(future)
 ```
 
 ## Multiplicative Seasonality
@@ -149,13 +236,27 @@ m.plot_components(forecast).savefig("components.png")
 [Explanation](https://facebook.github.io/prophet/docs/multiplicative_seasonality.html)
 
 ```ruby
-df = Daru::DataFrame.from_csv("example_air_passengers.csv")
+df = Rover.read_csv("example_air_passengers.csv")
 m = Prophet.new(seasonality_mode: "multiplicative")
 m.fit(df)
 future = m.make_future_dataframe(periods: 50, freq: "MS")
 forecast = m.predict(future)
 ```
 
+## Uncertainty Intervals
+
+Specify the width of uncertainty intervals (80% by default)
+
+```ruby
+Prophet.new(interval_width: 0.95)
+```
+
+Get uncertainty in seasonality
+
+```ruby
+Prophet.new(mcmc_samples: 300)
+```
+
 ## Non-Daily Data
 
 [Explanation](https://facebook.github.io/prophet/docs/non-daily_data.html)
@@ -163,17 +264,25 @@ forecast = m.predict(future)
 Sub-daily data
 
 ```ruby
-df = Daru::DataFrame.from_csv("example_yosemite_temps.csv")
+df = Rover.read_csv("example_yosemite_temps.csv")
 m = Prophet.new(changepoint_prior_scale: 0.01).fit(df)
 future = m.make_future_dataframe(periods: 300, freq: "H")
-fcst = m.predict(future)
-m.plot(fcst).savefig("forecast.png")
+forecast = m.predict(future)
 ```
 
 ## Resources
 
 - [Forecasting at Scale](https://peerj.com/preprints/3190.pdf)
 
+## Upgrading
+
+### 0.2.0
+
+Prophet now uses [Rover](https://github.com/ankane/rover) instead of Daru. Two changes you may need to make are:
+
+- `Rover.read_csv` instead of `Daru::DataFrame.from_csv`
+- `df[["ds", "yhat"]]` instead of `df["ds", "yhat"]`
+
 ## Credits
 
 This library was ported from the [Prophet Python library](https://github.com/facebook/prophet) and is available under the same license.

data/lib/prophet.rb

@@ -1,6 +1,6 @@
 # dependencies
 require "cmdstan"
-require "daru"
+require "rover"
 require "numo/narray"
 
 # stdlib
@@ -20,4 +20,67 @@ module Prophet
   def self.new(**kwargs)
     Forecaster.new(**kwargs)
   end
+
+  def self.forecast(series, count: 10)
+    raise ArgumentError, "Series must have at least 10 data points" if series.size < 10
+
+    # check type to determine output format
+    # check for before converting to time
+    keys = series.keys
+    dates = keys.all? { |k| k.is_a?(Date) }
+    time_zone = keys.first.time_zone if keys.first.respond_to?(:time_zone)
+    utc = keys.first.utc? if keys.first.respond_to?(:utc?)
+    times = keys.map(&:to_time)
+
+    day = times.all? { |t| t.hour == 0 && t.min == 0 && t.sec == 0 && t.nsec == 0 }
+    week = day && times.map { |k| k.wday }.uniq.size == 1
+    month = day && times.all? { |k| k.day == 1 }
+    quarter = month && times.all? { |k| k.month % 3 == 1 }
+    year = quarter && times.all? { |k| k.month == 1 }
+
+    freq =
+      if year
+        "YS"
+      elsif quarter
+        "QS"
+      elsif month
+        "MS"
+      elsif week
+        "W"
+      elsif day
+        "D"
+      else
+        diff = Rover::Vector.new(times).sort.diff.to_numo[1..-1]
+        min_diff = diff.min.to_i
+
+        # could be another common divisor
+        # but keep it simple for now
+        raise "Unknown frequency" unless (diff % min_diff).eq(0).all?
+
+        "#{min_diff}S"
+      end
+
+    # use series, not times, so dates are handled correctly
+    df = Rover::DataFrame.new({"ds" => series.keys, "y" => series.values})
+
+    m = Prophet.new
+    m.logger.level = ::Logger::FATAL # no logging
+    m.fit(df)
+
+    future = m.make_future_dataframe(periods: count, include_history: false, freq: freq)
+    forecast = m.predict(future)
+    result = forecast[["ds", "yhat"]].to_a
+
+    # use the same format as input
+    if dates
+      result.each { |v| v["ds"] = v["ds"].to_date }
+    elsif time_zone
+      result.each { |v| v["ds"] = v["ds"].in_time_zone(time_zone) }
+    elsif utc
+      result.each { |v| v["ds"] = v["ds"].utc }
+    else
+      result.each { |v| v["ds"] = v["ds"].localtime }
+    end
+    result.map { |v| [v["ds"], v["yhat"]] }.to_h
+  end
 end

data/lib/prophet/forecaster.rb

@@ -82,12 +82,12 @@ module Prophet
         raise ArgumentError, "Parameter \"changepoint_range\" must be in [0, 1]"
       end
       if @holidays
-        if !@holidays.is_a?(Daru::DataFrame) && @holidays.vectors.include?("ds") && @holidays.vectors.include?("holiday")
+        if !@holidays.is_a?(Rover::DataFrame) && @holidays.include?("ds") && @holidays.include?("holiday")
           raise ArgumentError, "holidays must be a DataFrame with \"ds\" and \"holiday\" columns."
         end
         @holidays["ds"] = to_datetime(@holidays["ds"])
-        has_lower = @holidays.vectors.include?("lower_window")
-        has_upper = @holidays.vectors.include?("upper_window")
+        has_lower = @holidays.include?("lower_window")
+        has_upper = @holidays.include?("upper_window")
         if has_lower ^ has_upper # xor
           raise ArgumentError, "Holidays must have both lower_window and upper_window, or neither"
         end
@@ -141,7 +141,7 @@ module Prophet
     end
 
     def setup_dataframe(df, initialize_scales: false)
-      if df.vectors.include?("y")
+      if df.include?("y")
         df["y"] = df["y"].map(&:to_f)
         raise ArgumentError "Found infinity in column y." unless df["y"].all?(&:finite?)
       end
@@ -152,18 +152,18 @@ module Prophet
       raise ArgumentError, "Found NaN in column ds." if df["ds"].any?(&:nil?)
 
       @extra_regressors.each_key do |name|
-        if !df.vectors.include?(name)
+        if !df.include?(name)
           raise ArgumentError, "Regressor #{name.inspect} missing from dataframe"
         end
         df[name] = df[name].map(&:to_f)
-        if df[name].any?(&:nil)
+        if df[name].any?(&:nil?)
           raise ArgumentError, "Found NaN in column #{name.inspect}"
         end
       end
       @seasonalities.values.each do |props|
         condition_name = props[:condition_name]
         if condition_name
-          if !df.vectors.include?(condition_name)
+          if !df.include?(condition_name)
             raise ArgumentError, "Condition #{condition_name.inspect} missing from dataframe"
           end
           if df.where(!df[condition_name].in([true, false])).any?
@@ -172,36 +172,33 @@ module Prophet
         end
       end
 
-      if df.index.name == "ds"
-        df.index.name = nil
-      end
-      df = df.sort(["ds"])
+      df = df.sort_by { |r| r["ds"] }
 
       initialize_scales(initialize_scales, df)
 
-      if @logistic_floor && !df.vectors.include?("floor")
+      if @logistic_floor && !df.include?("floor")
         raise ArgumentError, "Expected column \"floor\"."
       else
         df["floor"] = 0
       end
 
       if @growth == "logistic"
-        unless df.vectors.include?("cap")
+        unless df.include?("cap")
           raise ArgumentError, "Capacities must be supplied for logistic growth in column \"cap\""
         end
-        if df.where(df["cap"] <= df["floor"]).size > 0
+        if df[df["cap"] <= df["floor"]].size > 0
           raise ArgumentError, "cap must be greater than floor (which defaults to 0)."
         end
-        df["cap_scaled"] = (df["cap"] - df["floor"]) / @y_scale
+        df["cap_scaled"] = (df["cap"] - df["floor"]) / @y_scale.to_f
       end
 
       df["t"] = (df["ds"] - @start) / @t_scale.to_f
-      if df.vectors.include?("y")
-        df["y_scaled"] = (df["y"] - df["floor"]) / @y_scale
+      if df.include?("y")
+        df["y_scaled"] = (df["y"] - df["floor"]) / @y_scale.to_f
       end
 
       @extra_regressors.each do |name, props|
-        df[name] = ((df[name] - props["mu"]) / props["std"])
+        df[name] = (df[name] - props[:mu]) / props[:std].to_f
       end
 
       df
@@ -218,32 +215,40 @@ module Prophet
     end
 
     def set_changepoints
-      hist_size = (@history.shape[0] * @changepoint_range).floor
+      if @changepoints
+        if @changepoints.size > 0
+          too_low = @changepoints.min < @history["ds"].min
+          too_high = @changepoints.max > @history["ds"].max
+          if too_low || too_high
+            raise ArgumentError, "Changepoints must fall within training data."
+          end
+        end
+      else
+        hist_size = (@history.shape[0] * @changepoint_range).floor
 
-      if @n_changepoints + 1 > hist_size
-        @n_changepoints = hist_size - 1
-        logger.info "n_changepoints greater than number of observations. Using #{@n_changepoints}"
-      end
+        if @n_changepoints + 1 > hist_size
+          @n_changepoints = hist_size - 1
+          logger.info "n_changepoints greater than number of observations. Using #{@n_changepoints}"
+        end
 
-      if @n_changepoints > 0
-        step = (hist_size - 1) / @n_changepoints.to_f
-        cp_indexes = (@n_changepoints + 1).times.map { |i| (i * step).round }
-        @changepoints = @history["ds"][*cp_indexes][1..-1]
-      else
-        @changepoints = []
+        if @n_changepoints > 0
+          step = (hist_size - 1) / @n_changepoints.to_f
+          cp_indexes = (@n_changepoints + 1).times.map { |i| (i * step).round }
+          @changepoints = Rover::Vector.new(@history["ds"].to_a.values_at(*cp_indexes)).tail(-1)
+        else
+          @changepoints = []
+        end
       end
 
       if @changepoints.size > 0
-        @changepoints_t = Numo::NArray.asarray(((@changepoints - @start) / @t_scale.to_f).to_a).sort
+        @changepoints_t = (@changepoints.map(&:to_i).sort.to_numo.cast_to(Numo::DFloat) - @start.to_i) / @t_scale.to_f
       else
         @changepoints_t = Numo::NArray.asarray([0])
       end
     end
 
     def fourier_series(dates, period, series_order)
-      start = Time.utc(1970).to_i
-      # uses to_datetime first so we get UTC
-      t = Numo::DFloat.asarray(dates.map { |v| v.to_i - start }) / (3600 * 24.0)
+      t = dates.map(&:to_i).to_numo / (3600 * 24.0)
 
       # no need for column_stack
       series_order.times.flat_map do |i|
@@ -255,11 +260,11 @@ module Prophet
 
     def make_seasonality_features(dates, period, series_order, prefix)
       features = fourier_series(dates, period, series_order)
-      Daru::DataFrame.new(features.map.with_index { |v, i| ["#{prefix}_delim_#{i + 1}", v] }.to_h)
+      Rover::DataFrame.new(features.map.with_index { |v, i| ["#{prefix}_delim_#{i + 1}", v] }.to_h)
     end
 
     def construct_holiday_dataframe(dates)
-      all_holidays = Daru::DataFrame.new
+      all_holidays = Rover::DataFrame.new
       if @holidays
         all_holidays = @holidays.dup
       end
@@ -271,12 +276,12 @@ module Prophet
       # Drop future holidays not previously seen in training data
       if @train_holiday_names
         # Remove holiday names didn't show up in fit
-        all_holidays = all_holidays.where(all_holidays["holiday"].in(@train_holiday_names))
+        all_holidays = all_holidays[all_holidays["holiday"].in?(@train_holiday_names)]
 
         # Add holiday names in fit but not in predict with ds as NA
-        holidays_to_add = Daru::DataFrame.new(
-          "holiday" => @train_holiday_names.where(!@train_holiday_names.in(all_holidays["holiday"]))
-        )
+        holidays_to_add = Rover::DataFrame.new({
+          "holiday" => @train_holiday_names[!@train_holiday_names.in?(all_holidays["holiday"])]
+        })
         all_holidays = all_holidays.concat(holidays_to_add)
       end
 
@@ -310,7 +315,7 @@ module Prophet
 
         lw.upto(uw).each do |offset|
           occurrence = dt ? dt + offset : nil
-          loc = occurrence ? row_index.index(occurrence) : nil
+          loc = occurrence ? row_index.to_a.index(occurrence) : nil
           key = "#{row["holiday"]}_delim_#{offset >= 0 ? "+" : "-"}#{offset.abs}"
           if loc
             expanded_holidays[key][loc] = 1.0
@@ -319,14 +324,14 @@ module Prophet
           end
         end
       end
-      holiday_features = Daru::DataFrame.new(expanded_holidays)
-      # # Make sure column order is consistent
-      holiday_features = holiday_features[*holiday_features.vectors.sort]
-      prior_scale_list = holiday_features.vectors.map { |h| prior_scales[h.split("_delim_")[0]] }
+      holiday_features = Rover::DataFrame.new(expanded_holidays)
+      # Make sure column order is consistent
+      holiday_features = holiday_features[holiday_features.vector_names.sort]
+      prior_scale_list = holiday_features.vector_names.map { |h| prior_scales[h.split("_delim_")[0]] }
       holiday_names = prior_scales.keys
       # Store holiday names used in fit
-      if !@train_holiday_names
-        @train_holiday_names = Daru::Vector.new(holiday_names)
+      if @train_holiday_names.nil?
+        @train_holiday_names = Rover::Vector.new(holiday_names)
       end
       [holiday_features, prior_scale_list, holiday_names]
     end
@@ -424,16 +429,16 @@ module Prophet
         modes[@seasonality_mode].concat(holiday_names)
       end
 
-      # # Additional regressors
+      # Additional regressors
       @extra_regressors.each do |name, props|
-        seasonal_features << df[name].to_df
+        seasonal_features << Rover::DataFrame.new({name => df[name]})
         prior_scales << props[:prior_scale]
         modes[props[:mode]] << name
       end
 
-      # # Dummy to prevent empty X
+      # Dummy to prevent empty X
       if seasonal_features.size == 0
-        seasonal_features << Daru::DataFrame.new("zeros" => [0] * df.shape[0])
+        seasonal_features << Rover::DataFrame.new({"zeros" => [0] * df.shape[0]})
         prior_scales << 1.0
       end
 
@@ -445,16 +450,16 @@ module Prophet
     end
 
     def regressor_column_matrix(seasonal_features, modes)
-      components = Daru::DataFrame.new(
+      components = Rover::DataFrame.new(
         "col" => seasonal_features.shape[1].times.to_a,
-        "component" => seasonal_features.vectors.map { |x| x.split("_delim_")[0] }
+        "component" => seasonal_features.vector_names.map { |x| x.split("_delim_")[0] }
       )
 
-      # # Add total for holidays
+      # Add total for holidays
       if @train_holiday_names
         components = add_group_component(components, "holidays", @train_holiday_names.uniq)
       end
-      # # Add totals additive and multiplicative components, and regressors
+      # Add totals additive and multiplicative components, and regressors
       ["additive", "multiplicative"].each do |mode|
         components = add_group_component(components, mode + "_terms", modes[mode])
         regressors_by_mode = @extra_regressors.select { |r, props| props[:mode] == mode }
@@ -465,20 +470,15 @@ module Prophet
         modes[mode] << mode + "_terms"
         modes[mode] << "extra_regressors_" + mode
       end
-      # # After all of the additive/multiplicative groups have been added,
+      # After all of the additive/multiplicative groups have been added,
       modes[@seasonality_mode] << "holidays"
-      # # Convert to a binary matrix
-      component_cols = Daru::DataFrame.crosstab_by_assignation(
-        components["col"], components["component"], [1] * components.size
-      )
-      component_cols.each_vector do |v|
-        v.map! { |vi| vi.nil? ? 0 : vi }
-      end
-      component_cols.rename_vectors(:_id => "col")
+      # Convert to a binary matrix
+      component_cols = components["col"].crosstab(components["component"])
+      component_cols["col"] = component_cols.delete("_")
 
       # Add columns for additive and multiplicative terms, if missing
       ["additive_terms", "multiplicative_terms"].each do |name|
-        component_cols[name] = 0 unless component_cols.vectors.include?(name)
+        component_cols[name] = 0 unless component_cols.include?(name)
       end
 
       # TODO validation
@@ -487,10 +487,10 @@ module Prophet
     end
 
     def add_group_component(components, name, group)
-      new_comp = components.where(components["component"].in(group)).dup
+      new_comp = components[components["component"].in?(group)].dup
       group_cols = new_comp["col"].uniq
       if group_cols.size > 0
-        new_comp = Daru::DataFrame.new("col" => group_cols, "component" => [name] * group_cols.size)
+        new_comp = Rover::DataFrame.new({"col" => group_cols, "component" => name})
         components = components.concat(new_comp)
       end
       components
@@ -566,8 +566,8 @@ module Prophet
     end
 
     def linear_growth_init(df)
-      i0 = df["ds"].index.min
-      i1 = df["ds"].index.max
+      i0 = 0
+      i1 = df.size - 1
       t = df["t"][i1] - df["t"][i0]
       k = (df["y_scaled"][i1] - df["y_scaled"][i0]) / t
       m = df["y_scaled"][i0] - k * df["t"][i0]
@@ -575,8 +575,8 @@ module Prophet
     end
 
     def logistic_growth_init(df)
-      i0 = df["ds"].index.min
-      i1 = df["ds"].index.max
+      i0 = 0
+      i1 = df.size - 1
       t = df["t"][i1] - df["t"][i0]
 
       # Force valid values, in case y > cap or y < 0
@@ -605,8 +605,13 @@ module Prophet
     def fit(df, **kwargs)
       raise Error, "Prophet object can only be fit once" if @history
 
-      history = df.where(!df["y"].in([nil, Float::NAN]))
-      raise Error, "Data has less than 2 non-nil rows" if history.shape[0] < 2
+      if defined?(Daru::DataFrame) && df.is_a?(Daru::DataFrame)
+        df = Rover::DataFrame.new(df.to_h)
+      end
+      raise ArgumentError, "Must be a data frame" unless df.is_a?(Rover::DataFrame)
+
+      history = df[!df["y"].missing]
+      raise Error, "Data has less than 2 non-nil rows" if history.size < 2
 
       @history_dates = to_datetime(df["ds"]).sort
       history = setup_dataframe(history, initialize_scales: true)
@@ -654,8 +659,8 @@ module Prophet
         # Nothing to fit.
         @params = stan_init
         @params["sigma_obs"] = 1e-9
-        @params.each do |par|
-          @params[par] = Numo::NArray.asarray(@params[par])
+        @params.each do |par, _|
+          @params[par] = Numo::NArray.asarray([@params[par]])
         end
       elsif @mcmc_samples > 0
         @params = @stan_backend.sampling(stan_init, dat, @mcmc_samples, **kwargs)
@@ -666,8 +671,10 @@ module Prophet
       # If no changepoints were requested, replace delta with 0s
       if @changepoints.size == 0
         # Fold delta into the base rate k
-        @params["k"] = @params["k"] + @params["delta"].reshape(-1)
-        @params["delta"] = Numo::DFloat.zeros(@params["delta"].shape).reshape(-1, 1)
+        # Numo doesn't support -1 with reshape
+        negative_one = @params["delta"].shape.inject(&:*)
+        @params["k"] = @params["k"] + @params["delta"].reshape(negative_one)
+        @params["delta"] = Numo::DFloat.zeros(@params["delta"].shape).reshape(negative_one, 1)
       end
 
       self
@@ -693,10 +700,10 @@ module Prophet
 
       # Drop columns except ds, cap, floor, and trend
       cols = ["ds", "trend"]
-      cols << "cap" if df.vectors.include?("cap")
+      cols << "cap" if df.include?("cap")
       cols << "floor" if @logistic_floor
       # Add in forecast components
-      df2 = df_concat_axis_one([df[*cols], intervals, seasonal_components])
+      df2 = df_concat_axis_one([df[cols], intervals, seasonal_components])
       df2["yhat"] = df2["trend"] * (df2["multiplicative_terms"] + 1) + df2["additive_terms"]
       df2
     end
@@ -731,8 +738,7 @@ module Prophet
         k_t[indx] += deltas[s]
         m_t[indx] += gammas[s]
       end
-      # need df_values to prevent memory from blowing up
-      df_values(cap) / (1 + Numo::NMath.exp(-k_t * (t - m_t)))
+      cap.to_numo / (1 + Numo::NMath.exp(-k_t * (t - m_t)))
     end
 
     def predict_trend(df)
@@ -758,10 +764,10 @@ module Prophet
         upper_p = 100 * (1.0 + @interval_width) / 2
       end
 
-      x = df_values(seasonal_features)
+      x = seasonal_features.to_numo
       data = {}
-      component_cols.vectors.each do |component|
-        beta_c = @params["beta"] * Numo::NArray.asarray(component_cols[component].to_a)
+      component_cols.vector_names.each do |component|
+        beta_c =  @params["beta"] * component_cols[component].to_numo
 
         comp = x.dot(beta_c.transpose)
         if @component_modes["additive"].include?(component)
@@ -769,11 +775,11 @@ module Prophet
         end
         data[component] = comp.mean(axis: 1, nan: true)
         if @uncertainty_samples
-          data[component + "_lower"] = percentile(comp, lower_p, axis: 1)
-          data[component + "_upper"] = percentile(comp, upper_p, axis: 1)
+          data[component + "_lower"] = comp.percentile(lower_p, axis: 1)
+          data[component + "_upper"] = comp.percentile(upper_p, axis: 1)
         end
       end
-      Daru::DataFrame.new(data)
+      Rover::DataFrame.new(data)
     end
 
     def sample_posterior_predictive(df)
@@ -784,9 +790,9 @@ module Prophet
       seasonal_features, _, component_cols, _ = make_all_seasonality_features(df)
 
       # convert to Numo for performance
-      seasonal_features = df_values(seasonal_features)
-      additive_terms = df_values(component_cols["additive_terms"])
-      multiplicative_terms = df_values(component_cols["multiplicative_terms"])
+      seasonal_features = seasonal_features.to_numo
+      additive_terms = component_cols["additive_terms"].to_numo
+      multiplicative_terms = component_cols["multiplicative_terms"].to_numo
 
       sim_values = {"yhat" => [], "trend" => []}
       n_iterations.times do |i|
@@ -823,11 +829,11 @@ module Prophet
 
       series = {}
       ["yhat", "trend"].each do |key|
-        series["#{key}_lower"] = percentile(sim_values[key], lower_p, axis: 1)
-        series["#{key}_upper"] = percentile(sim_values[key], upper_p, axis: 1)
+        series["#{key}_lower"] = sim_values[key].percentile(lower_p, axis: 1)
+        series["#{key}_upper"] = sim_values[key].percentile(upper_p, axis: 1)
       end
 
-      Daru::DataFrame.new(series)
+      Rover::DataFrame.new(series)
     end
 
     def sample_model(df, seasonal_features, iteration, s_a, s_m)
@@ -848,8 +854,8 @@ module Prophet
     end
 
     def sample_predictive_trend(df, iteration)
-      k = @params["k"][iteration, true]
-      m = @params["m"][iteration, true]
+      k = @params["k"][iteration]
+      m = @params["m"][iteration]
       deltas = @params["delta"][iteration, true]
 
       t = Numo::NArray.asarray(df["t"].to_a)
@@ -889,82 +895,81 @@ module Prophet
       trend * @y_scale + Numo::NArray.asarray(df["floor"].to_a)
     end
 
-    def percentile(a, percentile, axis:)
-      raise Error, "Axis must be 1" if axis != 1
-
-      sorted = a.sort(axis: axis)
-      x = percentile / 100.0 * (sorted.shape[axis] - 1)
-      r = x % 1
-      i = x.floor
-      # this should use axis, but we only need axis: 1
-      if i == sorted.shape[axis] - 1
-        sorted[true, -1]
-      else
-        sorted[true, i] + r * (sorted[true, i + 1] - sorted[true, i])
-      end
-    end
-
     def make_future_dataframe(periods:, freq: "D", include_history: true)
       raise Error, "Model has not been fit" unless @history_dates
       last_date = @history_dates.max
+      # TODO add more freq
+      # https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases
       case freq
+      when /\A\d+S\z/
+        secs = freq.to_i
+        dates = (periods + 1).times.map { |i| last_date + i * secs }
+      when "H"
+        hour = 3600
+        dates = (periods + 1).times.map { |i| last_date + i * hour }
       when "D"
         # days have constant length with UTC (no DST or leap seconds)
-        dates = (periods + 1).times.map { |i| last_date + i * 86400 }
-      when "H"
-        dates = (periods + 1).times.map { |i| last_date + i * 3600 }
+        day = 24 * 3600
+        dates = (periods + 1).times.map { |i| last_date + i * day }
+      when "W"
+        week = 7 * 24 * 3600
+        dates = (periods + 1).times.map { |i| last_date + i * week }
       when "MS"
         dates = [last_date]
+        # TODO reset day from last date, but keep time
         periods.times do
           dates << dates.last.to_datetime.next_month.to_time.utc
         end
+      when "QS"
+        dates = [last_date]
+        # TODO reset day and month from last date, but keep time
+        periods.times do
+          dates << dates.last.to_datetime.next_month.next_month.next_month.to_time.utc
+        end
+      when "YS"
+        dates = [last_date]
+        # TODO reset day and month from last date, but keep time
+        periods.times do
+          dates << dates.last.to_datetime.next_year.to_time.utc
+        end
       else
         raise ArgumentError, "Unknown freq: #{freq}"
       end
       dates.select! { |d| d > last_date }
       dates = dates.last(periods)
-      dates = @history_dates + dates if include_history
-      Daru::DataFrame.new("ds" => dates)
+      dates = @history_dates.to_numo.concatenate(Numo::NArray.cast(dates)) if include_history
+      Rover::DataFrame.new({"ds" => dates})
     end
 
     private
 
-    # Time is prefer over DateTime Ruby
+    # Time is preferred over DateTime in Ruby docs
     # use UTC to be consistent with Python
     # and so days have equal length (no DST)
     def to_datetime(vec)
       return if vec.nil?
-      vec.map do |v|
-        case v
-        when Time
-          v.utc
-        when Date
-          v.to_datetime.to_time.utc
-        else
-          DateTime.parse(v.to_s).to_time.utc
+      vec =
+        vec.map do |v|
+          case v
+          when Time
+            v.utc
+          when Date
+            v.to_datetime.to_time.utc
+          else
+            DateTime.parse(v.to_s).to_time.utc
+          end
         end
-      end
+      Rover::Vector.new(vec)
     end
 
     # okay to do in-place
     def df_concat_axis_one(dfs)
       dfs[1..-1].each do |df|
-        df.each_vector_with_index do |v, k|
-          dfs[0][k] = v
-        end
+        dfs[0].merge!(df)
       end
       dfs[0]
     end
 
-    def df_values(df)
-      if df.is_a?(Daru::Vector)
-        Numo::NArray.asarray(df.to_a)
-      else
-        # TODO make more performant
-        Numo::NArray.asarray(df.to_matrix.to_a)
-      end
-    end
-
     # https://en.wikipedia.org/wiki/Poisson_distribution#Generating_Poisson-distributed_random_variables
     def poisson(lam)
       l = Math.exp(-lam)
@@ -979,7 +984,7 @@ module Prophet
 
     # https://en.wikipedia.org/wiki/Laplace_distribution#Generating_values_from_the_Laplace_distribution
     def laplace(loc, scale, size)
-      u = Numo::DFloat.new(size).rand - 0.5
+      u = Numo::DFloat.new(size).rand(-0.5, 0.5)
       loc - scale * u.sign * Numo::NMath.log(1 - 2 * u.abs)
     end
   end

data/lib/prophet/holidays.rb

@@ -6,7 +6,7 @@ module Prophet
     end
 
     def make_holidays_df(year_list, country)
-      holidays_df.where(holidays_df["country"].eq(country) & holidays_df["year"].in(year_list))["ds", "holiday"]
+      holidays_df[(holidays_df["country"] == country) & (holidays_df["year"].in?(year_list))][["ds", "holiday"]]
     end
 
     # TODO marshal on installation
@@ -20,7 +20,7 @@ module Prophet
           holidays["country"] << row["country"]
           holidays["year"] << row["year"]
         end
-        Daru::DataFrame.new(holidays)
+        Rover::DataFrame.new(holidays)
       end
     end
   end

data/lib/prophet/plot.rb

@@ -8,16 +8,16 @@ module Prophet
         fig = ax.get_figure
       end
       fcst_t = to_pydatetime(fcst["ds"])
-      ax.plot(to_pydatetime(@history["ds"]), @history["y"].map(&:to_f), "k.")
-      ax.plot(fcst_t, fcst["yhat"].map(&:to_f), ls: "-", c: "#0072B2")
-      if fcst.vectors.include?("cap") && plot_cap
-        ax.plot(fcst_t, fcst["cap"].map(&:to_f), ls: "--", c: "k")
+      ax.plot(to_pydatetime(@history["ds"]), @history["y"].to_a, "k.")
+      ax.plot(fcst_t, fcst["yhat"].to_a, ls: "-", c: "#0072B2")
+      if fcst.include?("cap") && plot_cap
+        ax.plot(fcst_t, fcst["cap"].to_a, ls: "--", c: "k")
       end
-      if @logistic_floor && fcst.vectors.include?("floor") && plot_cap
-        ax.plot(fcst_t, fcst["floor"].map(&:to_f), ls: "--", c: "k")
+      if @logistic_floor && fcst.include?("floor") && plot_cap
+        ax.plot(fcst_t, fcst["floor"].to_a, ls: "--", c: "k")
       end
       if uncertainty && @uncertainty_samples
-        ax.fill_between(fcst_t, fcst["yhat_lower"].map(&:to_f), fcst["yhat_upper"].map(&:to_f), color: "#0072B2", alpha: 0.2)
+        ax.fill_between(fcst_t, fcst["yhat_lower"].to_a, fcst["yhat_upper"].to_a, color: "#0072B2", alpha: 0.2)
       end
       # Specify formatting to workaround matplotlib issue #12925
       locator = dates.AutoDateLocator.new(interval_multiples: false)
@@ -33,25 +33,25 @@ module Prophet
 
     def plot_components(fcst, uncertainty: true, plot_cap: true, weekly_start: 0, yearly_start: 0, figsize: nil)
       components = ["trend"]
-      if @train_holiday_names && fcst.vectors.include?("holidays")
+      if @train_holiday_names && fcst.include?("holidays")
         components << "holidays"
       end
       # Plot weekly seasonality, if present
-      if @seasonalities["weekly"] && fcst.vectors.include?("weekly")
+      if @seasonalities["weekly"] && fcst.include?("weekly")
         components << "weekly"
       end
       # Yearly if present
-      if @seasonalities["yearly"] && fcst.vectors.include?("yearly")
+      if @seasonalities["yearly"] && fcst.include?("yearly")
         components << "yearly"
       end
       # Other seasonalities
-      components.concat(@seasonalities.keys.select { |name| fcst.vectors.include?(name) && !["weekly", "yearly"].include?(name) }.sort)
+      components.concat(@seasonalities.keys.select { |name| fcst.include?(name) && !["weekly", "yearly"].include?(name) }.sort)
       regressors = {"additive" => false, "multiplicative" => false}
       @extra_regressors.each do |name, props|
         regressors[props[:mode]] = true
       end
       ["additive", "multiplicative"].each do |mode|
-        if regressors[mode] && fcst.vectors.include?("extra_regressors_#{mode}")
+        if regressors[mode] && fcst.include?("extra_regressors_#{mode}")
           components << "extra_regressors_#{mode}"
         end
       end
@@ -93,6 +93,24 @@ module Prophet
       fig
     end
 
+    # in Python, this is a separate method
+    def add_changepoints_to_plot(ax, fcst, threshold: 0.01, cp_color: "r", cp_linestyle: "--", trend: true)
+      artists = []
+      if trend
+        artists << ax.plot(to_pydatetime(fcst["ds"]), fcst["trend"].to_a, c: cp_color)
+      end
+      signif_changepoints =
+        if @changepoints.size > 0
+          (@params["delta"].mean(axis: 0, nan: true).abs >= threshold).mask(@changepoints.to_numo)
+        else
+          []
+        end
+      to_pydatetime(signif_changepoints).each do |cp|
+        artists << ax.axvline(x: cp, c: cp_color, ls: cp_linestyle)
+      end
+      artists
+    end
+
     private
 
     def plot_forecast_component(fcst, name, ax: nil, uncertainty: true, plot_cap: false, figsize: [10, 6])
@@ -102,15 +120,15 @@ module Prophet
         ax = fig.add_subplot(111)
       end
       fcst_t = to_pydatetime(fcst["ds"])
-      artists += ax.plot(fcst_t, fcst[name].map(&:to_f), ls: "-", c: "#0072B2")
-      if fcst.vectors.include?("cap") && plot_cap
-        artists += ax.plot(fcst_t, fcst["cap"].map(&:to_f), ls: "--", c: "k")
+      artists += ax.plot(fcst_t, fcst[name].to_a, ls: "-", c: "#0072B2")
+      if fcst.include?("cap") && plot_cap
+        artists += ax.plot(fcst_t, fcst["cap"].to_a, ls: "--", c: "k")
       end
-      if @logistic_floor && fcst.vectors.include?("floor") && plot_cap
-        ax.plot(fcst_t, fcst["floor"].map(&:to_f), ls: "--", c: "k")
+      if @logistic_floor && fcst.include?("floor") && plot_cap
+        ax.plot(fcst_t, fcst["floor"].to_a, ls: "--", c: "k")
       end
       if uncertainty && @uncertainty_samples
-        artists += [ax.fill_between(fcst_t, fcst[name + "_lower"].map(&:to_f), fcst[name + "_upper"].map(&:to_f), color: "#0072B2", alpha: 0.2)]
+        artists += [ax.fill_between(fcst_t, fcst[name + "_lower"].to_a, fcst[name + "_upper"].to_a, color: "#0072B2", alpha: 0.2)]
       end
       # Specify formatting to workaround matplotlib issue #12925
       locator = dates.AutoDateLocator.new(interval_multiples: false)
@@ -127,17 +145,17 @@ module Prophet
     end
 
     def seasonality_plot_df(ds)
-      df_dict = {"ds" => ds, "cap" => [1.0] * ds.size, "floor" => [0.0] * ds.size}
-      @extra_regressors.each do |name|
-        df_dict[name] = [0.0] * ds.size
+      df_dict = {"ds" => ds, "cap" => 1.0, "floor" => 0.0}
+      @extra_regressors.each_key do |name|
+        df_dict[name] = 0.0
       end
       # Activate all conditional seasonality columns
       @seasonalities.values.each do |props|
         if props[:condition_name]
-          df_dict[props[:condition_name]] = [true] * ds.size
+          df_dict[props[:condition_name]] = true
         end
       end
-      df = Daru::DataFrame.new(df_dict)
+      df = Rover::DataFrame.new(df_dict)
       df = setup_dataframe(df)
       df
     end
@@ -154,9 +172,9 @@ module Prophet
       df_w = seasonality_plot_df(days)
       seas = predict_seasonal_components(df_w)
       days = days.map { |v| v.strftime("%A") }
-      artists += ax.plot(days.size.times.to_a, seas[name].map(&:to_f), ls: "-", c: "#0072B2")
+      artists += ax.plot(days.size.times.to_a, seas[name].to_a, ls: "-", c: "#0072B2")
       if uncertainty && @uncertainty_samples
-        artists += [ax.fill_between(days.size.times.to_a, seas[name + "_lower"].map(&:to_f), seas[name + "_upper"].map(&:to_f), color: "#0072B2", alpha: 0.2)]
+        artists += [ax.fill_between(days.size.times.to_a, seas[name + "_lower"].to_a, seas[name + "_upper"].to_a, color: "#0072B2", alpha: 0.2)]
       end
       ax.grid(true, which: "major", c: "gray", ls: "-", lw: 1, alpha: 0.2)
       ax.set_xticks(days.size.times.to_a)
@@ -180,9 +198,9 @@ module Prophet
       days = 365.times.map { |i| start + i + yearly_start }
       df_y = seasonality_plot_df(days)
       seas = predict_seasonal_components(df_y)
-      artists += ax.plot(to_pydatetime(df_y["ds"]), seas[name].map(&:to_f), ls: "-", c: "#0072B2")
+      artists += ax.plot(to_pydatetime(df_y["ds"]), seas[name].to_a, ls: "-", c: "#0072B2")
       if uncertainty && @uncertainty_samples
-        artists += [ax.fill_between(to_pydatetime(df_y["ds"]), seas[name + "_lower"].map(&:to_f), seas[name + "_upper"].map(&:to_f), color: "#0072B2", alpha: 0.2)]
+        artists += [ax.fill_between(to_pydatetime(df_y["ds"]), seas[name + "_lower"].to_a, seas[name + "_upper"].to_a, color: "#0072B2", alpha: 0.2)]
       end
       ax.grid(true, which: "major", c: "gray", ls: "-", lw: 1, alpha: 0.2)
       months = dates.MonthLocator.new((1..12).to_a, bymonthday: 1, interval: 2)
@@ -213,9 +231,9 @@ module Prophet
       days = plot_points.times.map { |i| Time.at(start + i * step).utc }
       df_y = seasonality_plot_df(days)
       seas = predict_seasonal_components(df_y)
-      artists += ax.plot(to_pydatetime(df_y["ds"]), seas[name].map(&:to_f), ls: "-", c: "#0072B2")
+      artists += ax.plot(to_pydatetime(df_y["ds"]), seas[name].to_a, ls: "-", c: "#0072B2")
       if uncertainty && @uncertainty_samples
-        artists += [ax.fill_between(to_pydatetime(df_y["ds"]), seas[name + "_lower"].map(&:to_f), seas[name + "_upper"].map(&:to_f), color: "#0072B2", alpha: 0.2)]
+        artists += [ax.fill_between(to_pydatetime(df_y["ds"]), seas[name + "_lower"].to_a, seas[name + "_upper"].to_a, color: "#0072B2", alpha: 0.2)]
       end
       ax.grid(true, which: "major", c: "gray", ls: "-", lw: 1, alpha: 0.2)
       step = (finish - start) / (7 - 1).to_f
@@ -263,7 +281,7 @@ module Prophet
 
     def to_pydatetime(v)
       datetime = PyCall.import_module("datetime")
-      v.map { |v| datetime.datetime.utcfromtimestamp(v.to_i) }
+      v.map { |v| datetime.datetime.utcfromtimestamp(v.to_i) }.to_a
     end
   end
 end

data/lib/prophet/stan_backend.rb

@@ -127,7 +127,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_matrix.to_a
+      stan_data["X"] = stan_data["X"].to_numo.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.1.0"
+  VERSION = "0.2.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prophet-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-09 00:00:00.000000000 Z
+date: 2020-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdstan
@@ -16,30 +16,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
-  name: daru
+  name: numo-narray
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.1.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.1.7
 - !ruby/object:Gem::Dependency
-  name: numo-narray
+  name: rover-df
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
+- !ruby/object:Gem::Dependency
+  name: daru
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: matplotlib
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +123,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby-prof
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="