mirror of
https://github.com/saymrwulf/prophet.git
synced 2026-05-16 21:00:16 +00:00
284 lines
7.6 KiB
Markdown
284 lines
7.6 KiB
Markdown
---
|
|
layout: docs
|
|
docid: "quick_start"
|
|
title: "Quick Start"
|
|
permalink: /docs/quick_start.html
|
|
---
|
|
## Python API
|
|
|
|
Prophet follows the `sklearn` model API. We create an instance of the `Prophet` class and then call its `fit` and `predict` methods.
|
|
|
|
The input to Prophet is always a dataframe with two columns: `ds` and `y`. The `ds` (datestamp) column must contain a date or datetime (either is fine). The `y` column must be numeric, and represents the measurement we wish to forecast.
|
|
|
|
As an example, let's look at a time series of daily page views for the Wikipedia page for [Peyton Manning](https://en.wikipedia.org/wiki/Peyton_Manning). We scraped this data using the [Wikipediatrend](https://cran.r-project.org/web/packages/wikipediatrend/vignettes/using-wikipediatrend.html) package in R. Peyton Manning provides a nice example because it illustrates some of Prophet's features, like multiple seasonality, changing growth rates, and the ability to model special days (such as Manning's playoff and superbowl appearances).
|
|
|
|
First we'll import the data and log-transform the y variable.
|
|
|
|
```python
|
|
# Python
|
|
import pandas as pd
|
|
import numpy as np
|
|
from fbprophet import Prophet
|
|
```
|
|
```python
|
|
# Python
|
|
df = pd.read_csv('../examples/example_wp_peyton_manning.csv')
|
|
df['y'] = np.log(df['y'])
|
|
df.head()
|
|
```
|
|
|
|
|
|
|
|
<div>
|
|
<table border="1" class="dataframe">
|
|
<thead>
|
|
<tr style="text-align: right;">
|
|
<th></th>
|
|
<th>ds</th>
|
|
<th>y</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<th>0</th>
|
|
<td>2007-12-10</td>
|
|
<td>9.590761</td>
|
|
</tr>
|
|
<tr>
|
|
<th>1</th>
|
|
<td>2007-12-11</td>
|
|
<td>8.519590</td>
|
|
</tr>
|
|
<tr>
|
|
<th>2</th>
|
|
<td>2007-12-12</td>
|
|
<td>8.183677</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3</th>
|
|
<td>2007-12-13</td>
|
|
<td>8.072467</td>
|
|
</tr>
|
|
<tr>
|
|
<th>4</th>
|
|
<td>2007-12-14</td>
|
|
<td>7.893572</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
|
|
|
|
|
|
We fit the model by instantiated a new `Prophet` object. Any settings to the forecasting procedure are passed into the constructor. Then you call its `fit` method and pass in the historical dataframe. Fitting should take 1-5 seconds.
|
|
|
|
```python
|
|
# Python
|
|
m = Prophet()
|
|
m.fit(df);
|
|
```
|
|
Predictions are then made on a dataframe with a column `ds` containing the dates for which a prediction is to be made. You can get a suitable dataframe that extends into the future a specified number of days using the helper method `Prophet.make_future_dataframe`. By default it will also include the dates from the history, so we will see the model fit as well.
|
|
|
|
```python
|
|
# Python
|
|
future = m.make_future_dataframe(periods=365)
|
|
future.tail()
|
|
```
|
|
|
|
|
|
|
|
<div>
|
|
<table border="1" class="dataframe">
|
|
<thead>
|
|
<tr style="text-align: right;">
|
|
<th></th>
|
|
<th>ds</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<th>3265</th>
|
|
<td>2017-01-15</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3266</th>
|
|
<td>2017-01-16</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3267</th>
|
|
<td>2017-01-17</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3268</th>
|
|
<td>2017-01-18</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3269</th>
|
|
<td>2017-01-19</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
|
|
|
|
|
|
The `predict` method will assign each row in `future` a predicted value which it names `yhat`. If you pass in historical dates, it will provide an in-sample fit. The `forecast` object here is a new dataframe that includes a column `yhat` with the forecast, as well as columns for components and uncertainty intervals.
|
|
|
|
```python
|
|
# Python
|
|
forecast = m.predict(future)
|
|
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()
|
|
```
|
|
|
|
|
|
|
|
<div>
|
|
<table border="1" class="dataframe">
|
|
<thead>
|
|
<tr style="text-align: right;">
|
|
<th></th>
|
|
<th>ds</th>
|
|
<th>yhat</th>
|
|
<th>yhat_lower</th>
|
|
<th>yhat_upper</th>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
<tr>
|
|
<th>3265</th>
|
|
<td>2017-01-15</td>
|
|
<td>8.205065</td>
|
|
<td>7.480528</td>
|
|
<td>8.889085</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3266</th>
|
|
<td>2017-01-16</td>
|
|
<td>8.530088</td>
|
|
<td>7.805730</td>
|
|
<td>9.296309</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3267</th>
|
|
<td>2017-01-17</td>
|
|
<td>8.317468</td>
|
|
<td>7.576534</td>
|
|
<td>9.060808</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3268</th>
|
|
<td>2017-01-18</td>
|
|
<td>8.150081</td>
|
|
<td>7.440242</td>
|
|
<td>8.906296</td>
|
|
</tr>
|
|
<tr>
|
|
<th>3269</th>
|
|
<td>2017-01-19</td>
|
|
<td>8.162015</td>
|
|
<td>7.433653</td>
|
|
<td>8.902665</td>
|
|
</tr>
|
|
</tbody>
|
|
</table>
|
|
</div>
|
|
|
|
|
|
|
|
You can plot the forecast by calling the `Prophet.plot` method and passing in your forecast dataframe.
|
|
|
|
```python
|
|
# Python
|
|
m.plot(forecast);
|
|
```
|
|
|
|
|
|
|
|
|
|
If you want to see the forecast components, you can use the `Prophet.plot_components` method. By default you'll see the trend, yearly seasonality, and weekly seasonality of the time series. If you include holidays, you'll see those here, too.
|
|
|
|
```python
|
|
# Python
|
|
m.plot_components(forecast);
|
|
```
|
|
|
|
|
|
|
|
|
|
## R API
|
|
|
|
In R, we use the normal model fitting API. We provide a `prophet` function that performs fitting and returns a model object. You can then call `predict` and `plot` on this model object.
|
|
|
|
```R
|
|
# R
|
|
library(prophet)
|
|
library(dplyr)
|
|
```
|
|
First we read in the data and create the outcome variable. As in the Python API, this is a dataframe with columns `ds` and `y`, containing the date and numeric value respectively. As above, we use here the log number of views to Petyon Manning's Wikipedia page.
|
|
|
|
```R
|
|
# R
|
|
df <- read.csv('../examples/example_wp_peyton_manning.csv') %>%
|
|
mutate(y = log(y))
|
|
```
|
|
We call the `prophet` function to fit the model. The first argument is the historical dataframe. Additional arguments control how Prophet fits the data and are described in later pages of this documentation.
|
|
|
|
```R
|
|
# R
|
|
m <- prophet(df)
|
|
```
|
|
Predictions are made on a dataframe with a column `ds` containing the dates for which predictions are to be made. The `make_future_dataframe` function takes the model object and a number of periods to forecast and produces a suitable dataframe. By default it will also include the historical dates so we can evaluate in-sample fit.
|
|
|
|
```R
|
|
# R
|
|
future <- make_future_dataframe(m, periods = 365)
|
|
tail(future)
|
|
```
|
|
|
|
ds
|
|
3264 2017-01-13
|
|
3265 2017-01-14
|
|
3266 2017-01-15
|
|
3267 2017-01-16
|
|
3268 2017-01-17
|
|
3269 2017-01-18
|
|
|
|
|
|
|
|
As with most modeling procedures in R, we use the generic `predict` function to get our forecast. The `forecast` object is a dataframe with a column `yhat` containing the forecast. It has additional columns for uncertainty intervals and seasonal components.
|
|
|
|
```R
|
|
# R
|
|
forecast <- predict(m, future)
|
|
tail(forecast[c('ds', 'yhat', 'yhat_lower', 'yhat_upper')])
|
|
```
|
|
|
|
ds yhat yhat_lower yhat_upper
|
|
3264 2017-01-13 8.052054 7.332958 8.698754
|
|
3265 2017-01-14 7.832396 7.077789 8.578120
|
|
3266 2017-01-15 8.214232 7.397416 8.922169
|
|
3267 2017-01-16 8.539239 7.786306 9.239885
|
|
3268 2017-01-17 8.326654 7.562416 9.042217
|
|
3269 2017-01-18 8.159337 7.449771 8.869469
|
|
|
|
|
|
|
|
You can use the generic `plot` function to plot the forecast, by passing in the model and the forecast dataframe.
|
|
|
|
```R
|
|
# R
|
|
plot(m, forecast)
|
|
```
|
|
|
|
|
|
|
|
|
|
You can use the `prophet_plot_components` function to see the forecast broken down into trend, weekly seasonality, and yearly seasonality.
|
|
|
|
```R
|
|
# R
|
|
prophet_plot_components(m, forecast)
|
|
```
|
|
|
|
|
|
|