diff --git a/docs/_docs/additional_topics.md b/docs/_docs/additional_topics.md
new file mode 100644
index 0000000..14bdc12
--- /dev/null
+++ b/docs/_docs/additional_topics.md
@@ -0,0 +1,119 @@
+---
+layout: docs
+docid: "additional_topics"
+title: "Additional Topics"
+permalink: /docs/additional_topics.html
+subsections:
+ - title: Saving models
+ id: saving-models
+ - title: Flat trend and custom trends
+ id: flat-trend-and-custom-trends
+ - title: Updating fitted models
+ id: updating-fitted-models
+---
+
+
+### Saving models
+
+
+
+It is possible to save fitted Prophet models so that they can be loaded and used later.
+
+
+
+In R, this is done with `saveRDS` and `readRDS`:
+
+
+```R
+# R
+saveRDS(m, file="model.RDS") # Save model
+m <- readRDS(file="model.RDS") # Load model
+```
+In Python, models should not be saved with pickle; the Stan backend attached to the model object will not pickle well, and will produce issues under certain versions of Python. Instead, you should use the built-in serialization functions to serialize the model to json:
+
+
+```python
+# Python
+import json
+from fbprophet.serialize import model_to_json, model_from_json
+
+with open('serialized_model.json', 'w') as fout:
+ json.dump(model_to_json(m), fout) # Save model
+
+with open('serialized_model.json', 'r') as fin:
+ m = model_from_json(json.load(fin)) # Load model
+```
+The json file will be portable across systems, and deserialization is backwards compatible with older versions of fbprophet.
+
+
+
+
+### Flat trend and custom trends
+
+
+
+For time series that exhibit strong seasonality patterns rather than trend changes, it may be useful to force the trend growth rate to be flat. This can be achieved simply by passing `growth=flat` when creating the model:
+
+
+```python
+# Python
+m = Prophet(growth='flat')
+```
+This is currently implemented only in the Python version of Prophet. Note that if this is used on a time series that doesn't have a constant trend, any trend will be fit with the noise term and so there will be high predictive uncertainty in the forecast.
+
+
+
+To use a trend besides these three built-in trend functions (piecewise linear, piecewise logistic growth, and flat), you can download the source code from github, modify the trend function as desired in a local branch, and then install that local version. This PR provides a good illustration of what must be done to implement a custom trend: https://github.com/facebook/prophet/pull/1466/files.
+
+
+
+
+### Updating fitted models
+
+
+
+A common setting for forecasting is fitting models that need to be updated as additional data come in. Prophet models can only be fit once, and a new model must be re-fit when new data become available. In most settings, model fitting is fast enough that there isn't any issue with re-fitting from scratch. However, it is possible to speed things up a little by warm-starting the fit from the model parameters of the earlier model. This code example shows how this can be done in Python:
+
+
+```python
+# Python
+def stan_init(m):
+ """Retrieve parameters from a trained model.
+
+ Retrieve parameters from a trained model in the format
+ used to initialize a new Stan model.
+
+ Parameters
+ ----------
+ m: A trained model of the Prophet class.
+
+ Returns
+ -------
+ A Dictionary containing retrieved parameters of m.
+
+ """
+ res = {}
+ for pname in ['k', 'm', 'sigma_obs']:
+ res[pname] = m.params[pname][0][0]
+ for pname in ['delta', 'beta']:
+ res[pname] = m.params[pname][0]
+ return res
+
+df = pd.read_csv('../examples/example_wp_log_peyton_manning.csv')
+df1 = df.loc[df['ds'] < '2016-01-19', :] # All data except the last day
+m1 = Prophet().fit(df1) # A model fit to all data except the last day
+
+
+%timeit m2 = Prophet().fit(df) # Adding the last day, fitting from scratch
+%timeit m2 = Prophet().fit(df, init=stan_init(m1)) # Adding the last day, warm-starting from m1
+```
+ 1.44 s ± 121 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+ 860 ms ± 203 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
+
+
+As can be seen, the parameters from the previous model are passed in to the fitting for the next with the kwarg `init`. In this case, model fitting was almost 2x faster when using warm starting. The speedup will generally depend on how much the optimal model parameters have changed with the addition of the new data.
+
+
+
+There are few caveats that should be kept in mind when considering warm-starting. First, warm-starting may work well for small updates to the data (like the addition of one day in the example above) but can be worse than fitting from scratch if there are large changes to the data (i.e., a lot of days have been added). This is because when a large amount of history is added, the location of the changepoints will be very different between the two models, and so the parameters from the previous model may actually produce a bad trend initialization. Second, as a detail, the number of changepoints need to be consistent from one model to the next or else an error will be raised because the changepoint prior parameter `delta` will be the wrong size.
+
diff --git a/docs/_docs/diagnostics.md b/docs/_docs/diagnostics.md
index 2b6ec16..c0c8eaa 100644
--- a/docs/_docs/diagnostics.md
+++ b/docs/_docs/diagnostics.md
@@ -4,6 +4,10 @@ docid: "diagnostics"
title: "Diagnostics"
permalink: /docs/diagnostics.html
subsections:
+ - title: Parallelizing cross validation
+ id: parallelizing-cross-validation
+ - title: Hyperparameter tuning
+ id: hyperparameter-tuning
---
Prophet includes functionality for time series cross validation to measure forecast error using historical data. This is done by selecting cutoff points in the history, and for each of them fitting the model using data only up to that cutoff point. We can then compare the forecasted values to the actual values. This figure illustrates a simulated historical forecast on the Peyton Manning dataset, where the model was fit to a initial history of 5 years, and a forecast was made on a one year horizon.
@@ -39,6 +43,13 @@ df_cv = cross_validation(m, initial='730 days', period='180 days', horizon = '36
df_cv.head()
```
+ HBox(children=(FloatProgress(value=0.0, max=11.0), HTML(value='')))
+
+
+
+
+
+
@@ -71,45 +82,45 @@ df_cv.head()
0
2010-02-16
-
8.956572
-
8.460049
-
9.460400
+
8.956828
+
8.479812
+
9.450908
8.242493
2010-02-15
1
2010-02-17
-
8.723004
-
8.200557
-
9.236561
+
8.723230
+
8.213162
+
9.217637
8.008033
2010-02-15
2
2010-02-18
-
8.606823
-
8.070835
-
9.123754
+
8.607021
+
8.119864
+
9.066214
8.045268
2010-02-15
3
2010-02-19
-
8.528688
-
8.034782
-
9.042712
+
8.528870
+
8.088676
+
9.024842
7.928766
2010-02-15
4
2010-02-20
-
8.270706
-
7.754891
-
8.739012
+
8.270872
+
7.740251
+
8.760655
7.745003
2010-02-15
@@ -123,7 +134,27 @@ In R, the argument `units` must be a type accepted by `as.difftime`, which is we
-The `performance_metrics` utility can be used to compute some useful statistics of the prediction performance (`yhat`, `yhat_lower`, and `yhat_upper` compared to `y`), as a function of the distance from the cutoff (how far into the future the prediction was). The statistics computed are mean squared error (MSE), root mean squared error (RMSE), mean absolute error (MAE), mean absolute percent error (MAPE), and coverage of the `yhat_lower` and `yhat_upper` estimates. These are computed on a rolling window of the predictions in `df_cv` after sorting by horizon (`ds` minus `cutoff`). By default 10% of the predictions will be included in each window, but this can be changed with the `rolling_window` argument.
+Custom cutoffs can also be supplied as a list of dates to to the `cutoffs` keyword in the `cross_validation` function in Python and R. For example, three cutoffs six months apart, would need to be passed to the `cutoffs` argument in a date format like:
+
+
+```R
+# R
+cutoffs <- as.Date(c('2013-02-15', '2013-08-15', '2014-02-15'))
+df.cv2 <- cross_validation(m, cutoffs = cutoffs, horizon = 365, units = 'days')
+```
+```python
+# Python
+cutoffs = pd.to_datetime(['2013-02-15', '2013-08-15', '2014-02-15'])
+df_cv2 = cross_validation(m, cutoffs=cutoffs, horizon='365 days')
+```
+
+ HBox(children=(FloatProgress(value=0.0, max=3.0), HTML(value='')))
+
+
+
+
+
+The `performance_metrics` utility can be used to compute some useful statistics of the prediction performance (`yhat`, `yhat_lower`, and `yhat_upper` compared to `y`), as a function of the distance from the cutoff (how far into the future the prediction was). The statistics computed are mean squared error (MSE), root mean squared error (RMSE), mean absolute error (MAE), mean absolute percent error (MAPE), median absolute percent error (MDAPE) and coverage of the `yhat_lower` and `yhat_upper` estimates. These are computed on a rolling window of the predictions in `df_cv` after sorting by horizon (`ds` minus `cutoff`). By default 10% of the predictions will be included in each window, but this can be changed with the `rolling_window` argument.
```R
@@ -163,6 +194,7 @@ df_p.head()
rmse
mae
mape
+
mdape
coverage
@@ -170,47 +202,52 @@ df_p.head()
0
37 days
-
0.495378
-
0.703831
-
0.505713
-
0.058593
-
0.680448
+
0.494800
+
0.703420
+
0.505277
+
0.058540
+
0.050149
+
0.676565
1
38 days
-
0.501134
-
0.707908
-
0.510680
-
0.059169
-
0.679077
+
0.500706
+
0.707606
+
0.510301
+
0.059120
+
0.049955
+
0.675423
2
39 days
-
0.523334
-
0.723418
-
0.516755
-
0.059766
-
0.677707
+
0.522967
+
0.723165
+
0.516433
+
0.059724
+
0.050078
+
0.672682
3
40 days
-
0.530625
-
0.728440
-
0.519645
-
0.060075
+
0.530259
+
0.728189
+
0.519331
+
0.060033
+
0.049706
0.678849
4
41 days
-
0.538117
-
0.733565
-
0.520663
-
0.060156
-
0.686386
+
0.537736
+
0.733305
+
0.520341
+
0.060114
+
0.049955
+
0.685244
@@ -231,12 +268,191 @@ from fbprophet.plot import plot_cross_validation_metric
fig = plot_cross_validation_metric(df_cv, metric='mape')
```
-
+
-The size of the rolling window in the figure can be changed with the optional argument `rolling_window`, which specifies the proportion of forecasts to use in each rolling window. The default is 0.1, corresponding to 10% of rows from `df_cv` included in each window; increasing this will lead to a smoother average curve in the figure.
+The size of the rolling window in the figure can be changed with the optional argument `rolling_window`, which specifies the proportion of forecasts to use in each rolling window. The default is 0.1, corresponding to 10% of rows from `df_cv` included in each window; increasing this will lead to a smoother average curve in the figure. The `initial` period should be long enough to capture all of the components of the model, in particular seasonalities and extra regressors: at least a year for yearly seasonality, at least a week for weekly seasonality, etc.
-The `initial` period should be long enough to capture all of the components of the model, in particular seasonalities and extra regressors: at least a year for yearly seasonality, at least a week for weekly seasonality, etc.
+
+
+
+### Parallelizing cross validation
+
+
+
+Cross-validation can also be run in parallel mode in Python, by setting specifying the `parallel` keyword. Four modes are supported
+
+
+
+* `parallel=None` (Default, no parallelization)
+
+* `parallel="processes"`
+
+* `parallel="threads"`
+
+* `parallel="dask"`
+
+
+
+For problems that aren't too big, we recommend using `parallel="processes"`. It will achieve the highest performance when the parallel cross validation can be done on a single machine. For large problems, a [Dask](https://dask.org) cluster can be used to do the cross validation on many machines. You will need to [install Dask](https://docs.dask.org/en/latest/install.html) separately, as it will not be installed with `fbprophet`.
+
+
+
+
+
+```python
+
+from dask.distributed import Client
+
+
+
+client = Client() # connect to the cluster
+
+df_cv = cross_validation(m, initial='730 days', period='180 days', horizon='365 days',
+
+ parallel="dask")
+
+```
+
+
+
+
+### Hyperparameter tuning
+
+
+
+Cross-validation can be used for tuning hyperparameters of the model, such as `changepoint_prior_scale` and `seasonality_prior_scale`. A Python example is given below, with a 4x4 grid of those two parameters, with parallelization over cutoffs. Here parameters are evaluated on RMSE averaged over a 30-day horizon, but different performance metrics may be appropriate for different problems.
+
+
+```python
+# Python
+import itertools
+import numpy as np
+import pandas as pd
+
+param_grid = {
+ 'changepoint_prior_scale': [0.001, 0.01, 0.1, 0.5],
+ 'seasonality_prior_scale': [0.01, 0.1, 1.0, 10.0],
+}
+
+# Generate all combinations of parameters
+all_params = [dict(zip(param_grid.keys(), v)) for v in itertools.product(*param_grid.values())]
+rmses = [] # Store the RMSEs for each params here
+
+# Use cross validation to evaluate all parameters
+for params in all_params:
+ m = Prophet(**params).fit(df) # Fit model with given params
+ df_cv = cross_validation(m, cutoffs=cutoffs, horizon='30 days', parallel="processes")
+ df_p = performance_metrics(df_cv, rolling_window=1)
+ rmses.append(df_p['rmse'].values[0])
+
+# Find the best parameters
+tuning_results = pd.DataFrame(all_params)
+tuning_results['rmse'] = rmses
+print(tuning_results)
+```
+ changepoint_prior_scale seasonality_prior_scale rmse
+ 0 0.001 0.01 0.757489
+ 1 0.001 0.10 0.745049
+ 2 0.001 1.00 0.753315
+ 3 0.001 10.00 0.763111
+ 4 0.010 0.01 0.536260
+ 5 0.010 0.10 0.538103
+ 6 0.010 1.00 0.544326
+ 7 0.010 10.00 0.520970
+ 8 0.100 0.01 0.524669
+ 9 0.100 0.10 0.521302
+ 10 0.100 1.00 0.520692
+ 11 0.100 10.00 0.515338
+ 12 0.500 0.01 0.532103
+ 13 0.500 0.10 0.528939
+ 14 0.500 1.00 0.525256
+ 15 0.500 10.00 0.524619
+
+
+```python
+# Python
+best_params = all_params[np.argmin(rmses)]
+print(best_params)
+```
+ {'changepoint_prior_scale': 0.1, 'seasonality_prior_scale': 10.0}
+
+
+Alternatively, parallelization could be done across parameter combinations by parallelizing the loop above.
+
+
+
+The Prophet model has a number of input parameters that one might consider tuning. Here are some general recommendations for hyperparameter tuning that may be a good starting place.
+
+
+
+**Parameters that can be tuned**
+
+- `changepoint_prior_scale`: This is probably the most impactful parameter. It determines the flexibility of the trend, and in particular how much the trend changes at the trend changepoints. As described in this documentation, if it is too small, the trend will be underfit and variance that should have been modeled with trend changes will instead end up being handled with the noise term. If it is too large, the trend will overfit and in the most extreme case you can end up with the trend capturing yearly seasonality. The default of 0.05 works for many time series, but this could be tuned; a range of [0.001, 0.5] would likely be about right. Parameters like this (regularization penalties; this is effectively a lasso penalty) are often tuned on a log scale.
+
+
+
+- `seasonality_prior_scale`: This parameter controls the flexibility of the seasonality. Similarly, a large value allows the seasonality to fit large fluctuations, a small value shrinks the magnitude of the seasonality. The default is 10., which applies basically no regularization. That is because we very rarely see overfitting here (there's inherent regularization with the fact that it is being modeled with a truncated Fourier series, so it's essentially low-pass filtered). A reasonable range for tuning it would probably be [0.01, 10]; when set to 0.01 you should find that the magnitude of seasonality is forced to be very small. This likely also makes sense on a log scale, since it is effectively an L2 penalty like in ridge regression.
+
+
+
+- `holidays_prior_scale`: This controls flexibility to fit holiday effects. Similar to seasonality_prior_scale, it defaults to 10.0 which applies basically no regularization, since we usually have multiple observations of holidays and can do a good job of estimating their effects. This could also be tuned on a range of [0.01, 10] as with seasonality_prior_scale.
+
+
+
+- `seasonality_mode`: Options are [`'additive'`, `'multiplicative'`]. Default is `'additive'`, but many business time series will have multiplicative seasonality. This is best identified just from looking at the time series and seeing if the magnitude of seasonal fluctuations grows with the magnitude of the time series (see the documentation here on multiplicative seasonality), but when that isn't possible, it could be tuned.
+
+
+
+**Maybe tune?**
+
+- `changepoint_range`: This is the proportion of the history in which the trend is allowed to change. This defaults to 0.8, 80% of the history, meaning the model will not fit any trend changes in the last 20% of the time series. This is fairly conservative, to avoid overfitting to trend changes at the very end of the time series where there isn't enough runway left to fit it well. With a human in the loop, this is something that can be identified pretty easily visually: one can pretty clearly see if the forecast is doing a bad job in the last 20%. In a fully-automated setting, it may be beneficial to be less conservative. It likely will not be possible to tune this parameter effectively with cross validation over cutoffs as described above. The ability of the model to generalize from a trend change in the last 10% of the time series will be hard to learn from looking at earlier cutoffs that may not have trend changes in the last 10%. So, this parameter is probably better not tuned, except perhaps over a large number of time series. In that setting, [0.8, 0.95] may be a reasonable range.
+
+
+
+**Parameters that would likely not be tuned**
+
+- `growth`: Options are 'linear' and 'logistic'. This likely will not be tuned; if there is a known saturating point and growth towards that point it will be included and the logistic trend will be used, otherwise it will be linear.
+
+
+
+- `changepoints`: This is for manually specifying the locations of changepoints. None by default, which automatically places them.
+
+
+
+- `n_changepoints`: This is the number of automatically placed changepoints. The default of 25 should be plenty to capture the trend changes in a typical time series (at least the type that Prophet would work well on anyway). Rather than increasing or decreasing the number of changepoints, it will likely be more effective to focus on increasing or decreasing the flexibility at those trend changes, which is done with `changepoint_prior_scale`.
+
+
+
+- `yearly_seasonality`: By default ('auto') this will turn yearly seasonality on if there is a year of data, and off otherwise. Options are ['auto', True, False]. If there is more than a year of data, rather than trying to turn this off during HPO, it will likely be more effective to leave it on and turn down seasonal effects by tuning `seasonality_prior_scale`.
+
+
+
+- `weekly_seasonality`: Same as for `yearly_seasonality`.
+
+
+
+- `daily_seasonality`: Same as for `yearly_seasonality`.
+
+
+
+- `holidays`: This is to pass in a dataframe of specified holidays. The holiday effects would be tuned with `holidays_prior_scale`.
+
+
+
+- `mcmc_samples`: Whether or not MCMC is used will likely be determined by factors like the length of the time series and the importance of parameter uncertainty (these considerations are described in the documentation).
+
+
+
+- `interval_width`: Prophet `predict` returns uncertainty intervals for each component, like `yhat_lower` and `yhat_upper` for the forecast `yhat`. These are computed as quantiles of the posterior predictive distribution, and `interval_width` specifies which quantiles to use. The default of 0.8 provides an 80% prediction interval. You could change that to 0.95 if you wanted a 95% interval. This will affect only the uncertainty interval, and will not change the forecast `yhat` at all and so does not need to be tuned.
+
+
+
+- `uncertainty_samples`: The uncertainty intervals are computed as quantiles from the posterior predictive interval, and the posterior predictive interval is estimated with Monte Carlo sampling. This parameter is the number of samples to use (defaults to 1000). The running time for predict will be linear in this number. Making it smaller will increase the variance (Monte Carlo error) of the uncertainty interval, and making it larger will reduce that variance. So, if the uncertainty estimates seem jagged this could be increased to further smooth them out, but it likely will not need to be changed. As with `interval_width`, this parameter only affects the uncertainty intervals and changing it will not affect in any way the forecast `yhat`; it does not need to be tuned.
+
+
+
+- `stan_backend`: If both pystan and cmdstanpy backends set up, the backend can be specified. The predictions will be the same, this will not be tuned.
diff --git a/docs/_docs/multiplicative_seasonality.md b/docs/_docs/multiplicative_seasonality.md
index 047dce2..299d6a9 100644
--- a/docs/_docs/multiplicative_seasonality.md
+++ b/docs/_docs/multiplicative_seasonality.md
@@ -87,5 +87,5 @@ m = Prophet(seasonality_mode='multiplicative')
m.add_seasonality('quarterly', period=91.25, fourier_order=8, mode='additive')
m.add_regressor('regressor', mode='additive')
```
-Additive and multiplicative extra regressors will show up in separate panels on the components plot.
+Additive and multiplicative extra regressors will show up in separate panels on the components plot. Note, however, that it is pretty unlikely to have a mix of additive and multiplicative seasonalities, so this will generally only be used if there is a reason to expect that to be the case.
diff --git a/docs/_docs/non-daily_data.md b/docs/_docs/non-daily_data.md
index 9d1ffb3..e1b73a8 100644
--- a/docs/_docs/non-daily_data.md
+++ b/docs/_docs/non-daily_data.md
@@ -10,6 +10,8 @@ subsections:
id: data-with-regular-gaps
- title: Monthly data
id: monthly-data
+ - title: Holidays with aggregated data
+ id: holidays-with-aggregated-data
---
@@ -157,8 +159,12 @@ m = Prophet(seasonality_mode='multiplicative', mcmc_samples=300).fit(df)
fcst = m.predict(future)
fig = m.plot_components(fcst)
```
+ WARNING:pystan:403 of 600 iterations saturated the maximum tree depth of 10 (67.2 %)
+ WARNING:pystan:Run again with max_treedepth larger than 10 to avoid saturation
+
+
-
+
The seasonality has low uncertainty at the start of each month where there are data points, but has very high posterior variance in between. When fitting Prophet to monthly data, only make monthly forecasts, which can be done by passing the frequency into `make_future_dataframe`:
@@ -172,10 +178,26 @@ plot(m, fcst)
```
```python
# Python
-future = m.make_future_dataframe(periods=120, freq='M')
+future = m.make_future_dataframe(periods=120, freq='MS')
fcst = m.predict(future)
fig = m.plot(fcst)
```

+
+In Python, the frequency can be anything from the pandas list of frequency strings here: https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases . Note that `MS` used here is month-start, meaning the data point is placed on the start of each month.
+
+
+
+In monthly data, yearly seasonality can also be modeled with binary extra regressors. In particular, the model can use 12 extra regressors like `is_jan`, `is_feb`, etc. where `is_jan` is 1 if the date is in Jan and 0 otherwise. This approach would avoid the within-month unidentifiability seen above. Be sure to use `yearly_seasonality=False` if monthly extra regressors are being added.
+
+
+
+
+## Holidays with aggregated data
+
+
+
+Holiday effects are applied to the particular date on which the holiday was specified. With data that has been aggregated to weekly or monthly frequency, holidays that don't fall on the particular date used in the data will be ignored: for example, a Monday holiday in a weekly time series where each data point is on a Sunday. To include holiday effects in the model, the holiday will need to be moved to the date in the history dataframe for which the effect is desired. Note that with weekly or monthly aggregated data, many holiday effects will be well-captured by the yearly seasonality, so added holidays may only be necessary for holidays that occur in different weeks throughout the time series.
+
diff --git a/docs/_docs/quick_start.md b/docs/_docs/quick_start.md
index 8ef5fe1..389e615 100644
--- a/docs/_docs/quick_start.md
+++ b/docs/_docs/quick_start.md
@@ -202,37 +202,37 @@ forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()
3265
2017-01-15
-
8.212942
-
7.463560
-
8.937215
+
8.204125
+
7.449654
+
8.946255
3266
2017-01-16
-
8.537993
-
7.790259
-
9.267492
+
8.529148
+
7.792752
+
9.284594
3267
2017-01-17
-
8.325428
-
7.525675
-
9.059391
+
8.316555
+
7.563541
+
9.029357
3268
2017-01-18
-
8.158059
-
7.433634
-
8.883627
+
8.149153
+
7.384345
+
8.840279
3269
2017-01-19
-
8.170046
-
7.431801
-
8.840703
+
8.161075
+
7.430352
+
8.859482
@@ -262,18 +262,134 @@ fig2 = m.plot_components(forecast)

-An interactive figure of the forecast can be created with plotly. You will need to install plotly separately, as it will not by default be installed with fbprophet.
+An interactive figure of the forecast and components can be created with plotly. You will need to install plotly 4.0 or above separately, as it will not by default be installed with fbprophet. You will also need to install the `notebook` and `ipywidgets` packages.
```python
# Python
-from fbprophet.plot import plot_plotly
-import plotly.offline as py
-py.init_notebook_mode()
+from fbprophet.plot import plot_plotly, plot_components_plotly
-fig = plot_plotly(m, forecast) # This returns a plotly Figure
-py.iplot(fig)
+plot_plotly(m, forecast)
```
+
+
+
+
+
+
+
+
+
More details about the options available for each method are available in the docstrings, for example, via `help(Prophet)` or `help(Prophet.fit)`. The [R reference manual](https://cran.r-project.org/web/packages/prophet/prophet.pdf) on CRAN provides a concise list of all of the available functions, each of which has a Python equivalent.
@@ -350,7 +466,7 @@ You can use the generic `plot` function to plot the forecast, by passing in the
plot(m, forecast)
```
-
+
You can use the `prophet_plot_components` function to see the forecast broken down into trend, weekly seasonality, and yearly seasonality.
@@ -361,7 +477,7 @@ You can use the `prophet_plot_components` function to see the forecast broken do
prophet_plot_components(m, forecast)
```
-
+
An interactive plot of the forecast using Dygraphs can be made with the command `dyplot.prophet(m, forecast)`.
diff --git a/docs/_docs/seasonality,_holiday_effects,_and_regressors.md b/docs/_docs/seasonality,_holiday_effects,_and_regressors.md
index 1d8ceda..9ac63b4 100644
--- a/docs/_docs/seasonality,_holiday_effects,_and_regressors.md
+++ b/docs/_docs/seasonality,_holiday_effects,_and_regressors.md
@@ -285,7 +285,7 @@ m.train_holiday_names
-The holidays for each country are provided by the `holidays` package in Python. A list of available countries, and the country name to use, is available on their page: https://github.com/dr-prodigy/python-holidays. In addition to those countries, Prophet includes holidays for these countries: Brazil (BR), Indonesia (ID), India (IN), Malaysia (MY), Vietnam (VN), Thailand (TH), Philippines (PH), Turkey (TU), Pakistan (PK), Bangladesh (BD), Egypt (EG), China (CN), and Russian (RU).
+The holidays for each country are provided by the `holidays` package in Python. A list of available countries, and the country name to use, is available on their page: https://github.com/dr-prodigy/python-holidays. In addition to those countries, Prophet includes holidays for these countries: Brazil (BR), Indonesia (ID), India (IN), Malaysia (MY), Vietnam (VN), Thailand (TH), Philippines (PH), Pakistan (PK), Bangladesh (BD), Egypt (EG), China (CN), and Russian (RU), Korea (KR), Belarus (BY), and United Arab Emirates (AE).
@@ -652,11 +652,11 @@ NFL Sundays could also have been handled using the "holidays" interface describe
-The `add_regressor` function has optional arguments for specifying the prior scale (holiday prior scale is used by default) and whether or not the regressor is standardized - see the docstring with `help(Prophet.add_regressor)` in Python and `?add_regressor` in R. Note that regressors must be added prior to model fitting.
+The `add_regressor` function has optional arguments for specifying the prior scale (holiday prior scale is used by default) and whether or not the regressor is standardized - see the docstring with `help(Prophet.add_regressor)` in Python and `?add_regressor` in R. Note that regressors must be added prior to model fitting. Prophet will also raise an error if the regressor is constant throughout the history, since there is nothing to fit from it.
-The extra regressor must be known for both the history and for future dates. It thus must either be something that has known future values (such as `nfl_sunday`), or something that has separately been forecasted elsewhere. Prophet will also raise an error if the regressor is constant throughout the history, since there is nothing to fit from it.
+The extra regressor must be known for both the history and for future dates. It thus must either be something that has known future values (such as `nfl_sunday`), or something that has separately been forecasted elsewhere. The weather regressors used in the notebook linked above is a good example of an extra regressor that has forecasts that can be used for future values. One can also use as a regressor another time series that has been forecasted with a time series model, such as Prophet. For instance, if `r(t)` is included as a regressor for `y(t)`, Prophet can be used to forecast `r(t)` and then that forecast can be plugged in as the future values when forecasting `y(t)`. A note of caution around this approach: This will probably not be useful unless `r(t)` is somehow easier to forecast then `y(t)`. This is because error in the forecast of `r(t)` will produce error in the forecast of `y(t)`. One setting where this can be useful is in hierarchical time series, where there is top-level forecast that has higher signal-to-noise and is thus easier to forecast. Its forecast can be included in the forecast for each lower-level series.
diff --git a/docs/_docs/trend_changepoints.md b/docs/_docs/trend_changepoints.md
index 2a30c17..8f2723e 100644
--- a/docs/_docs/trend_changepoints.md
+++ b/docs/_docs/trend_changepoints.md
@@ -94,6 +94,9 @@ fig = m.plot(forecast)

+When visualizing the forecast, this parameter can be adjusted as needed if the trend seems to be over- or under-fit. In the fully-automated setting, see the documentation on cross validation for recommendations on how this parameter can be tuned.
+
+
### Specifying the locations of the changepoints
@@ -115,5 +118,5 @@ forecast = m.fit(df).predict(future)
fig = m.plot(forecast)
```
-
+
diff --git a/docs/static/diagnostics_files/diagnostics_11_0.png b/docs/static/diagnostics_files/diagnostics_11_0.png
deleted file mode 100644
index ce3452e..0000000
Binary files a/docs/static/diagnostics_files/diagnostics_11_0.png and /dev/null differ
diff --git a/docs/static/diagnostics_files/diagnostics_12_0.png b/docs/static/diagnostics_files/diagnostics_12_0.png
deleted file mode 100644
index 7765323..0000000
Binary files a/docs/static/diagnostics_files/diagnostics_12_0.png and /dev/null differ
diff --git a/docs/static/diagnostics_files/diagnostics_14_0.png b/docs/static/diagnostics_files/diagnostics_14_0.png
new file mode 100644
index 0000000..e974428
Binary files /dev/null and b/docs/static/diagnostics_files/diagnostics_14_0.png differ
diff --git a/docs/static/diagnostics_files/diagnostics_15_0.png b/docs/static/diagnostics_files/diagnostics_15_0.png
new file mode 100644
index 0000000..0810ddf
Binary files /dev/null and b/docs/static/diagnostics_files/diagnostics_15_0.png differ
diff --git a/docs/static/diagnostics_files/diagnostics_3_0.png b/docs/static/diagnostics_files/diagnostics_3_0.png
index ac50c9c..81a8ea7 100644
Binary files a/docs/static/diagnostics_files/diagnostics_3_0.png and b/docs/static/diagnostics_files/diagnostics_3_0.png differ
diff --git a/docs/static/non-daily_data_files/non-daily_data_16_0.png b/docs/static/non-daily_data_files/non-daily_data_16_0.png
index e7d55cc..dab0fc3 100644
Binary files a/docs/static/non-daily_data_files/non-daily_data_16_0.png and b/docs/static/non-daily_data_files/non-daily_data_16_0.png differ
diff --git a/docs/static/non-daily_data_files/non-daily_data_19_0.png b/docs/static/non-daily_data_files/non-daily_data_19_0.png
deleted file mode 100644
index 59bda79..0000000
Binary files a/docs/static/non-daily_data_files/non-daily_data_19_0.png and /dev/null differ
diff --git a/docs/static/non-daily_data_files/non-daily_data_19_1.png b/docs/static/non-daily_data_files/non-daily_data_19_1.png
new file mode 100644
index 0000000..5a4a39d
Binary files /dev/null and b/docs/static/non-daily_data_files/non-daily_data_19_1.png differ
diff --git a/docs/static/non-daily_data_files/non-daily_data_22_0.png b/docs/static/non-daily_data_files/non-daily_data_22_0.png
index 43d56ea..1d37b4c 100644
Binary files a/docs/static/non-daily_data_files/non-daily_data_22_0.png and b/docs/static/non-daily_data_files/non-daily_data_22_0.png differ
diff --git a/docs/static/non-daily_data_files/non-daily_data_4_0.png b/docs/static/non-daily_data_files/non-daily_data_4_0.png
index 72c415a..6996519 100644
Binary files a/docs/static/non-daily_data_files/non-daily_data_4_0.png and b/docs/static/non-daily_data_files/non-daily_data_4_0.png differ
diff --git a/docs/static/non-daily_data_files/non-daily_data_7_0.png b/docs/static/non-daily_data_files/non-daily_data_7_0.png
index 8d02a61..862217f 100644
Binary files a/docs/static/non-daily_data_files/non-daily_data_7_0.png and b/docs/static/non-daily_data_files/non-daily_data_7_0.png differ
diff --git a/docs/static/quick_start_files/quick_start_12_0.png b/docs/static/quick_start_files/quick_start_12_0.png
index 947cb19..7885fd8 100644
Binary files a/docs/static/quick_start_files/quick_start_12_0.png and b/docs/static/quick_start_files/quick_start_12_0.png differ
diff --git a/docs/static/quick_start_files/quick_start_14_0.png b/docs/static/quick_start_files/quick_start_14_0.png
index 5bfe03f..355483a 100644
Binary files a/docs/static/quick_start_files/quick_start_14_0.png and b/docs/static/quick_start_files/quick_start_14_0.png differ
diff --git a/docs/static/quick_start_files/quick_start_29_0.png b/docs/static/quick_start_files/quick_start_30_0.png
similarity index 100%
rename from docs/static/quick_start_files/quick_start_29_0.png
rename to docs/static/quick_start_files/quick_start_30_0.png
diff --git a/docs/static/quick_start_files/quick_start_31_0.png b/docs/static/quick_start_files/quick_start_32_0.png
similarity index 100%
rename from docs/static/quick_start_files/quick_start_31_0.png
rename to docs/static/quick_start_files/quick_start_32_0.png
diff --git a/docs/static/trend_changepoints_files/trend_changepoints_19_1.png b/docs/static/trend_changepoints_files/trend_changepoints_20_1.png
similarity index 100%
rename from docs/static/trend_changepoints_files/trend_changepoints_19_1.png
rename to docs/static/trend_changepoints_files/trend_changepoints_20_1.png
diff --git a/docs/static/trend_changepoints_files/trend_changepoints_20_0.png b/docs/static/trend_changepoints_files/trend_changepoints_21_0.png
similarity index 100%
rename from docs/static/trend_changepoints_files/trend_changepoints_20_0.png
rename to docs/static/trend_changepoints_files/trend_changepoints_21_0.png
diff --git a/notebooks/additional_topics.ipynb b/notebooks/additional_topics.ipynb
index 0d1341a..f3a9aa2 100644
--- a/notebooks/additional_topics.ipynb
+++ b/notebooks/additional_topics.ipynb
@@ -2,24 +2,18 @@
"cells": [
{
"cell_type": "code",
- "execution_count": 9,
- "metadata": {},
+ "execution_count": 1,
+ "metadata": {
+ "block_hidden": true
+ },
"outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "The rpy2.ipython extension is already loaded. To reload it, use:\n",
- " %reload_ext rpy2.ipython\n"
- ]
- },
{
"data": {
"text/plain": [
- ""
+ ""
]
},
- "execution_count": 9,
+ "execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
@@ -45,13 +39,19 @@
},
{
"cell_type": "code",
- "execution_count": 11,
- "metadata": {},
+ "execution_count": 2,
+ "metadata": {
+ "block_hidden": true
+ },
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
+ "WARNING:rpy2.rinterface_lib.callbacks:R[write to console]: Loading required package: Rcpp\n",
+ "\n",
+ "WARNING:rpy2.rinterface_lib.callbacks:R[write to console]: Loading required package: rlang\n",
+ "\n",
"WARNING:rpy2.rinterface_lib.callbacks:R[write to console]: Disabling yearly seasonality. Run prophet with yearly.seasonality=TRUE to override this.\n",
"\n",
"WARNING:rpy2.rinterface_lib.callbacks:R[write to console]: Disabling daily seasonality. Run prophet with daily.seasonality=TRUE to override this.\n",
@@ -84,7 +84,7 @@
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
@@ -102,7 +102,7 @@
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
@@ -134,7 +134,7 @@
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
@@ -161,15 +161,15 @@
},
{
"cell_type": "code",
- "execution_count": 15,
+ "execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "1.26 s ± 21.2 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
- "716 ms ± 7.3 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
+ "1.44 s ± 121 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n",
+ "860 ms ± 203 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
]
}
],
@@ -216,6 +216,7 @@
}
],
"metadata": {
+ "celltoolbar": "Edit Metadata",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
diff --git a/notebooks/diagnostics.ipynb b/notebooks/diagnostics.ipynb
index 8ee987a..2f31a91 100644
--- a/notebooks/diagnostics.ipynb
+++ b/notebooks/diagnostics.ipynb
@@ -6,7 +6,29 @@
"metadata": {
"block_hidden": true
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "622a0104e841488fae81864678a008b3",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(FloatProgress(value=0.0, max=3.0), HTML(value='')))"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n"
+ ]
+ }
+ ],
"source": [
"%load_ext rpy2.ipython\n",
"%matplotlib inline\n",
@@ -20,7 +42,13 @@
"df = pd.read_csv('../examples/example_wp_log_peyton_manning.csv')\n",
"m = Prophet()\n",
"m.fit(df)\n",
- "future = m.make_future_dataframe(periods=366)"
+ "future = m.make_future_dataframe(periods=366)\n",
+ "\n",
+ "from fbprophet.diagnostics import cross_validation\n",
+ "df_cv = cross_validation(\n",
+ " m, '365 days', initial='1825 days', period='365 days')\n",
+ "cutoff = df_cv['cutoff'].unique()[0]\n",
+ "df_cv = df_cv[df_cv['cutoff'].values == cutoff]"
]
},
{
@@ -67,28 +95,7 @@
"outputs": [
{
"data": {
- "application/vnd.jupyter.widget-view+json": {
- "model_id": "4d1861d99a414fd19b0ad8d4daf98f76",
- "version_major": 2,
- "version_minor": 0
- },
- "text/plain": [
- "HBox(children=(FloatProgress(value=0.0, max=3.0), HTML(value='')))"
- ]
- },
- "metadata": {},
- "output_type": "display_data"
- },
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "\n"
- ]
- },
- {
- "data": {
- "image/png": "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\n",
+ "image/png": "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\n",
"text/plain": [
""
]
@@ -98,12 +105,6 @@
}
],
"source": [
- "from fbprophet.diagnostics import cross_validation\n",
- "df_cv = cross_validation(\n",
- " m, '365 days', initial='1825 days', period='365 days')\n",
- "cutoff = df_cv['cutoff'].unique()[0]\n",
- "df_cv = df_cv[df_cv['cutoff'].values == cutoff]\n",
- "\n",
"fig = plt.figure(facecolor='w', figsize=(10, 6))\n",
"ax = fig.add_subplot(111)\n",
"ax.plot(m.history['ds'].values, m.history['y'], 'k.')\n",
@@ -664,7 +665,7 @@
"\n",
"The Prophet model has a number of input parameters that one might consider tuning. Here are some general recommendations for hyperparameter tuning that may be a good starting place.\n",
"\n",
- "#### Parameters that can be tuned\n",
+ "**Parameters that can be tuned**\n",
"- `changepoint_prior_scale`: This is probably the most impactful parameter. It determines the flexibility of the trend, and in particular how much the trend changes at the trend changepoints. As described in this documentation, if it is too small, the trend will be underfit and variance that should have been modeled with trend changes will instead end up being handled with the noise term. If it is too large, the trend will overfit and in the most extreme case you can end up with the trend capturing yearly seasonality. The default of 0.05 works for many time series, but this could be tuned; a range of [0.001, 0.5] would likely be about right. Parameters like this (regularization penalties; this is effectively a lasso penalty) are often tuned on a log scale.\n",
"\n",
"- `seasonality_prior_scale`: This parameter controls the flexibility of the seasonality. Similarly, a large value allows the seasonality to fit large fluctuations, a small value shrinks the magnitude of the seasonality. The default is 10., which applies basically no regularization. That is because we very rarely see overfitting here (there's inherent regularization with the fact that it is being modeled with a truncated Fourier series, so it's essentially low-pass filtered). A reasonable range for tuning it would probably be [0.01, 10]; when set to 0.01 you should find that the magnitude of seasonality is forced to be very small. This likely also makes sense on a log scale, since it is effectively an L2 penalty like in ridge regression.\n",
@@ -673,10 +674,10 @@
"\n",
"- `seasonality_mode`: Options are [`'additive'`, `'multiplicative'`]. Default is `'additive'`, but many business time series will have multiplicative seasonality. This is best identified just from looking at the time series and seeing if the magnitude of seasonal fluctuations grows with the magnitude of the time series (see the documentation here on multiplicative seasonality), but when that isn't possible, it could be tuned.\n",
"\n",
- "#### Maybe tune?\n",
+ "**Maybe tune?**\n",
"- `changepoint_range`: This is the proportion of the history in which the trend is allowed to change. This defaults to 0.8, 80% of the history, meaning the model will not fit any trend changes in the last 20% of the time series. This is fairly conservative, to avoid overfitting to trend changes at the very end of the time series where there isn't enough runway left to fit it well. With a human in the loop, this is something that can be identified pretty easily visually: one can pretty clearly see if the forecast is doing a bad job in the last 20%. In a fully-automated setting, it may be beneficial to be less conservative. It likely will not be possible to tune this parameter effectively with cross validation over cutoffs as described above. The ability of the model to generalize from a trend change in the last 10% of the time series will be hard to learn from looking at earlier cutoffs that may not have trend changes in the last 10%. So, this parameter is probably better not tuned, except perhaps over a large number of time series. In that setting, [0.8, 0.95] may be a reasonable range.\n",
"\n",
- "#### Parameters that would likely not be tuned\n",
+ "**Parameters that would likely not be tuned**\n",
"- `growth`: Options are 'linear' and 'logistic'. This likely will not be tuned; if there is a known saturating point and growth towards that point it will be included and the logistic trend will be used, otherwise it will be linear.\n",
"\n",
"- `changepoints`: This is for manually specifying the locations of changepoints. None by default, which automatically places them.\n",
diff --git a/notebooks/trend_changepoints.ipynb b/notebooks/trend_changepoints.ipynb
index 98ccf1d..8197b2e 100644
--- a/notebooks/trend_changepoints.ipynb
+++ b/notebooks/trend_changepoints.ipynb
@@ -318,7 +318,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "A recommended starting range for `changepoint_prior_scale` would be between 0.001 and 1, although this is data dependant. Depending on how many changepoints are specified, 1 would likely be effectively unregularized. A random search for $x$ in logarithmic scale (.e.g. between -3 and 0) using the `cross_validation` function for diagnostics, along with visual inspection of the plot would help determine the optimal $x$ for the prior. The actual prior scale can then be computed as $10^{x}$"
+ "When visualizing the forecast, this parameter can be adjusted as needed if the trend seems to be over- or under-fit. In the fully-automated setting, see the documentation on cross validation for recommendations on how this parameter can be tuned."
]
},
{