prophet-rb 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e97133837196d4e1c97d69687d42f2d97e552d7be897f5e7a805efb5bab73e32
-  data.tar.gz: 4450d57d2c3da8632011f9f5a802891586b3e19347abe377e533ba5e8922708f
+  metadata.gz: 2b37dc1a6be57b67cd740727e0bf4ac0b3a4cf2e27ed19647b631094696787da
+  data.tar.gz: 892af24ebdd897d7dba904ed7b11a83390533666de13bb3f57172e26839ade3a
 SHA512:
-  metadata.gz: 6f0ed88d1a93d2f15e9750640833dbd889d8dea86255c8ec29c0fdc608ce27d17a0f617cbcaaee0be4b469b8e945f0ead9161875907a44a0555173e0f1a2c984
-  data.tar.gz: 485b4742b5267a8540445a87d59320a6ba5cc5589192369d22d69bfc1002d1ae2cb822a88a547ab63ff113e44b5ba47db51c45acb4bedc84079afd57210ea4ed
+  metadata.gz: 53bc289290cf1a7861419634a057253f3727994c2e911247af0adf7e39688a15c019e180274cb8dd1e2a140e94dafc90ef7ff996319446b535c5f08a9090a990
+  data.tar.gz: 6b4ecdfcfb03f3e9da68f244fd8d25f5f9bee9a854bdc4d9f68d4907f59260a485df323eb70cc60cdc68e1c1e0d5e9b5431313785bd22da72758fd90fbda7bd2

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.0 (2020-05-13)
+
+- Switched from Daru to Rover
+
 ## 0.1.1 (2020-04-10)
 
 - Added `add_changepoints_to_plot`

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://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
 
@@ -31,7 +31,7 @@ Check out the [Prophet documentation](https://facebook.github.io/prophet/docs/qu
 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 = Rover.read_csv("example_wp_log_peyton_manning.csv")
 df.head(5)
 ```
 
@@ -107,7 +107,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,7 +146,7 @@ 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(
+playoffs = Rover::DataFrame.new(
   "holiday" => ["playoff"] * 14,
   "ds" => ["2008-01-13", "2009-01-03", "2010-01-16",
            "2010-01-24", "2010-02-07", "2011-01-08",
@@ -156,7 +156,7 @@ playoffs = Daru::DataFrame.new(
   "lower_window" => [0] * 14,
   "upper_window" => [1] * 14
 )
-superbowls = Daru::DataFrame.new(
+superbowls = Rover::DataFrame.new(
   "holiday" => ["superbowl"] * 3,
   "ds" => ["2010-02-07", "2014-02-02", "2016-02-07"],
   "lower_window" => [0] * 3,
@@ -208,7 +208,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 +236,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)

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,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
@@ -613,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)
@@ -701,10 +698,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 +736,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)
@@ -766,10 +762,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 +773,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 +788,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 +827,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)
@@ -897,21 +893,6 @@ 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
@@ -938,48 +919,39 @@ module Prophet
       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 +966,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

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
@@ -97,11 +97,11 @@ module Prophet
     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"].map(&:to_f), c: cp_color)
+        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)
+          (@params["delta"].mean(axis: 0, nan: true).abs >= threshold).mask(@changepoints.to_numo)
         else
           []
         end
@@ -120,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)
@@ -145,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}
+      df_dict = {"ds" => ds, "cap" => 1.0, "floor" => 0.0}
       @extra_regressors.each_key do |name|
-        df_dict[name] = [0.0] * ds.size
+        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
@@ -172,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)
@@ -198,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)
@@ -231,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
@@ -281,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.1"
+  VERSION = "0.2.0"
 end

data/lib/prophet.rb

@@ -1,6 +1,6 @@
 # dependencies
 require "cmdstan"
-require "daru"
+require "rover"
 require "numo/narray"
 
 # stdlib

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prophet-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-10 00:00:00.000000000 Z
+date: 2020-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cmdstan
@@ -25,21 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         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:
     - - ">="
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5'
 - !ruby/object:Gem::Dependency
-  name: matplotlib
+  name: daru
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ruby-prof
+  name: matplotlib
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="