prophet-rb 0.1.1 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e97133837196d4e1c97d69687d42f2d97e552d7be897f5e7a805efb5bab73e32
-  data.tar.gz: 4450d57d2c3da8632011f9f5a802891586b3e19347abe377e533ba5e8922708f
+  metadata.gz: 506ab7cfb738d7f7289db812134b2fb64d6371da66e7586a1bcc254b26c6fa1c
+  data.tar.gz: ed97303bb3563bdebe86cf9865ec04142e9b3fa0e3f7bfdea8ae6a8a2ff8570f
 SHA512:
-  metadata.gz: 6f0ed88d1a93d2f15e9750640833dbd889d8dea86255c8ec29c0fdc608ce27d17a0f617cbcaaee0be4b469b8e945f0ead9161875907a44a0555173e0f1a2c984
-  data.tar.gz: 485b4742b5267a8540445a87d59320a6ba5cc5589192369d22d69bfc1002d1ae2cb822a88a547ab63ff113e44b5ba47db51c45acb4bedc84079afd57210ea4ed
+  metadata.gz: 5339ac3f8e7f26539137dc23b40d481013bc1ec082a008221edff00ea574ab08617956849e7cd221af40e9b12105630cbe294f8b5e2cfa1a33670d9c1fcd970c
+  data.tar.gz: 63b64fbef8414f65dfb39b7c266e780790f28b42cc6f2a0da415885b293c57ba309d50243e9d9ad2d61d93fe034017a31871cef26eed5e33b01cc651816eed3c

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.2.4 (2021-04-02)
+
+- Added support for flat growth
+
+## 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`

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,7 +10,7 @@ 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://github.com/ankane/prophet/workflows/build/badge.svg?branch=master)](https://github.com/ankane/prophet/actions)
 
 ## Installation
 
@@ -20,19 +20,47 @@ Add this line to your application’s Gemfile:
 gem 'prophet-rb'
 ```
 
-## Documentation
+## Simple 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.
+Get future predictions for a time series
 
-## Quick Start
+```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 advanced API follows the Python API and supports the same features. It uses [Rover](https://github.com/ankane/rover) for data frames.
+
+## 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
@@ -54,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 |
@@ -69,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
@@ -90,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
 
@@ -98,7 +126,7 @@ 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
 
@@ -107,7 +135,7 @@ m.plot_components(forecast).savefig("components.png")
 Forecast logistic growth instead of linear
 
 ```ruby
-df = Daru::DataFrame.from_csv("example_wp_log_R.csv")
+df = Rover.read_csv("example_wp_log_R.csv")
 df["cap"] = 8.5
 m = Prophet.new(growth: "logistic")
 m.fit(df)
@@ -146,21 +174,21 @@ m = Prophet.new(changepoints: ["2014-01-01"])
 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)
 
@@ -208,7 +236,7 @@ forecast = m.predict(future)
 [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")
@@ -236,7 +264,7 @@ Prophet.new(mcmc_samples: 300)
 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")
 forecast = m.predict(future)
@@ -246,6 +274,15 @@ forecast = m.predict(future)
 
 - [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

@@ -75,19 +75,19 @@ module Prophet
     end
 
     def validate_inputs
-      if !["linear", "logistic"].include?(@growth)
-        raise ArgumentError, "Parameter \"growth\" should be \"linear\" or \"logistic\"."
+      if !["linear", "logistic", "flat"].include?(@growth)
+        raise ArgumentError, "Parameter \"growth\" should be \"linear\", \"logistic\", or \"flat\"."
       end
       if @changepoint_range < 0 || @changepoint_range > 1
         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,7 +152,7 @@ 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)
@@ -163,7 +163,7 @@ module Prophet
       @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
@@ -237,21 +234,21 @@ module Prophet
         if @n_changepoints > 0
           step = (hist_size - 1) / @n_changepoints.to_f
           cp_indexes = (@n_changepoints + 1).times.map { |i| (i * step).round }
-          @changepoints = ensure_arr(@history["ds"][*cp_indexes].to_a.last(cp_indexes.size - 1))
+          @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::DFloat.cast(@changepoints.map(&:to_i).sort) - @start.to_i) / @t_scale.to_f
+        @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)
-      t = Numo::DFloat.asarray(dates.map(&:to_i)) / (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|
@@ -263,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
@@ -279,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
 
@@ -318,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
@@ -327,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
@@ -432,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
 
@@ -453,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 }
@@ -473,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
@@ -495,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
@@ -574,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]
@@ -583,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
@@ -610,11 +602,22 @@ module Prophet
       [k, m]
     end
 
+    def flat_growth_init(df)
+      k = 0
+      m = df["y_scaled"].mean
+      [k, m]
+    end
+
     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)
@@ -627,6 +630,8 @@ module Prophet
 
       set_changepoints
 
+      trend_indicator = {"linear" => 0, "logistic" => 1, "flat" => 2}
+
       dat = {
         "T" => history.shape[0],
         "K" => seasonal_features.shape[1],
@@ -637,7 +642,7 @@ module Prophet
         "X" => seasonal_features,
         "sigmas" => prior_scales,
         "tau" => @changepoint_prior_scale,
-        "trend_indicator" => @growth == "logistic" ? 1 : 0,
+        "trend_indicator" => trend_indicator[@growth],
         "s_a" => component_cols["additive_terms"],
         "s_m" => component_cols["multiplicative_terms"]
       }
@@ -645,6 +650,9 @@ module Prophet
       if @growth == "linear"
         dat["cap"] = Numo::DFloat.zeros(@history.shape[0])
         kinit = linear_growth_init(history)
+      elsif @growth == "flat"
+        dat["cap"] = Numo::DFloat.zeros(@history.shape[0])
+        kinit = flat_growth_init(history)
       else
         dat["cap"] = history["cap_scaled"]
         kinit = logistic_growth_init(history)
@@ -658,12 +666,12 @@ module Prophet
         "sigma_obs" => 1
       }
 
-      if history["y"].min == history["y"].max && @growth == "linear"
+      if history["y"].min == history["y"].max && (@growth == "linear" || @growth == "flat")
         # 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)
@@ -674,8 +682,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
@@ -701,10 +711,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
@@ -739,8 +749,12 @@ 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 flat_trend(t, m)
+      m_t = m * t.new_ones
+      m_t
     end
 
     def predict_trend(df)
@@ -751,9 +765,11 @@ module Prophet
       t = Numo::NArray.asarray(df["t"].to_a)
       if @growth == "linear"
         trend = piecewise_linear(t, deltas, k, m, @changepoints_t)
-      else
+      elsif @growth == "logistic"
         cap = df["cap_scaled"]
         trend = piecewise_logistic(t, cap, deltas, k, m, @changepoints_t)
+      elsif @growth == "flat"
+        trend = flat_trend(t, m)
       end
 
       trend * @y_scale + Numo::NArray.asarray(df["floor"].to_a)
@@ -766,10 +782,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)
@@ -777,11 +793,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)
@@ -792,9 +808,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|
@@ -831,11 +847,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)
@@ -889,35 +905,25 @@ module Prophet
 
       if @growth == "linear"
         trend = piecewise_linear(t, deltas, k, m, changepoint_ts)
-      else
+      elsif @growth == "logistic"
         cap = df["cap_scaled"]
         trend = piecewise_logistic(t, cap, deltas, k, m, changepoint_ts)
+      elsif @growth == "flat"
+        trend = flat_trend(t, m)
       end
 
       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 }
@@ -930,56 +936,60 @@ module Prophet
         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)
@@ -994,13 +1004,8 @@ 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
-
-    def ensure_arr(value)
-      value = [value] unless value.is_a?(Array)
-      value
-    end
   end
 end