class Prophet

class Prophet(builtins.object)

Prophet(
growth='linear', 
changepoints=None, 
n_changepoints=25, 
changepoint_range=0.8, 
yearly_seasonality='auto', 
weekly_seasonality='auto', 
daily_seasonality='auto', 
holidays=None,
seasonality_mode='additive', 
seasonality_prior_scale=10.0, 
holidays_prior_scale=10.0, 
changepoint_prior_scale=0.05, 
mcmc_samples=0, 
interval_width=0.8, 
uncertainty_samples=1000
)
Prophet forecaster.

Parameters
----------
growth: String 'linear' or 'logistic' to specify a linear or logistic
    trend.
changepoints: List of dates at which to include potential changepoints. If
    not specified, potential changepoints are selected automatically.
n_changepoints: Number of potential changepoints to include. Not used
    if input `changepoints` is supplied. If `changepoints` is not supplied,
    then n_changepoints potential changepoints are selected uniformly from
    the first `changepoint_range` proportion of the history.
changepoint_range: Proportion of history in which trend changepoints will
    be estimated. Defaults to 0.8 for the first 80%. Not used if
    `changepoints` is specified.
    Not used if input `changepoints` is supplied.
yearly_seasonality: Fit yearly seasonality.
    Can be 'auto', True, False, or a number of Fourier terms to generate.
weekly_seasonality: Fit weekly seasonality.
    Can be 'auto', True, False, or a number of Fourier terms to generate.
daily_seasonality: Fit daily seasonality.
    Can be 'auto', True, False, or a number of Fourier terms to generate.
holidays: pd.DataFrame with columns holiday (string) and ds (date type)
    and optionally columns lower_window and upper_window which specify a
    range of days around the date to be included as holidays.
    lower_window=-2 will include 2 days prior to the date as holidays. Also
    optionally can have a column prior_scale specifying the prior scale for
    that holiday.
seasonality_mode: 'additive' (default) or 'multiplicative'.
seasonality_prior_scale: Parameter modulating the strength of the
    seasonality model. Larger values allow the model to fit larger seasonal
    fluctuations, smaller values dampen the seasonality. Can be specified
    for individual seasonalities using add_seasonality.
holidays_prior_scale: Parameter modulating the strength of the holiday
    components model, unless overridden in the holidays input.
changepoint_prior_scale: Parameter modulating the flexibility of the
    automatic changepoint selection. Large values will allow many
    changepoints, small values will allow few changepoints.
mcmc_samples: Integer, if greater than 0, will do full Bayesian inference
    with the specified number of MCMC samples. If 0, will do MAP
    estimation.
interval_width: Float, width of the uncertainty intervals provided
    for the forecast. If mcmc_samples=0, this will be only the uncertainty
    in the trend using the MAP estimate of the extrapolated generative
    model. If mcmc.samples>0, this will be integrated over all model
    parameters, which will include uncertainty in seasonality.
uncertainty_samples: Number of simulated draws used to estimate
    uncertainty intervals.

Methods defined here:

__init__(  self, growth='linear', changepoints=None, n_changepoints=25, changepoint_range=0.8,  yearly_seasonality='auto',  weekly_seasonality='auto',  daily_seasonality='auto',  holidays=None,  seasonality_mode='additive',   easonality_prior_scale=10.0,  holidays_prior_scale=10.0,  changepoint_prior_scale=0.05,  mcmc_samples=0,  interval_width=0.8,  uncertainty_samples=1000)
    Initialize self.  See help(type(self)) for accurate signature.

add_country_holidays(self, country_name)
    Add in built-in holidays for the specified country.
    
    These holidays will be included in addition to any specified on model
    initialization.
    
    Holidays will be calculated for arbitrary date ranges in the history
    and future. See the online documentation for the list of countries with
    built-in holidays.
    
    Built-in country holidays can only be set for a single country.
    
    Parameters
    ----------
    country_name: Name of the country, like 'UnitedStates' or 'US'
    
    Returns
    -------
    The prophet object.

add_group_component(self, components, name, group)
    Adds a component with given name that contains all of the components
    in group.
    
    Parameters
    ----------
    components: Dataframe with components.
    name: Name of new group component.
    group: List of components that form the group.
    
    Returns
    -------
    Dataframe with components.

add_regressor(self, name, prior_scale=None, standardize='auto', mode=None)
    Add an additional regressor to be used for fitting and predicting.
    
    The dataframe passed to `fit` and `predict` will have a column with the
    specified name to be used as a regressor. When standardize='auto', the
    regressor will be standardized unless it is binary. The regression
    coefficient is given a prior with the specified scale parameter.
    Decreasing the prior scale will add additional regularization. If no
    prior scale is provided, self.holidays_prior_scale will be used.
    Mode can be specified as either 'additive' or 'multiplicative'. If not
    specified, self.seasonality_mode will be used. 'additive' means the
    effect of the regressor will be added to the trend, 'multiplicative'
    means it will multiply the trend.
    
    Parameters
    ----------
    name: string name of the regressor.
    prior_scale: optional float scale for the normal prior. If not
        provided, self.holidays_prior_scale will be used.
    standardize: optional, specify whether this regressor will be
        standardized prior to fitting. Can be 'auto' (standardize if not
        binary), True, or False.
    mode: optional, 'additive' or 'multiplicative'. Defaults to
        self.seasonality_mode.
    
    Returns
    -------
    The prophet object.

add_seasonality(self, name, period, fourier_order, prior_scale=None, mode=None, condition_name=None)
    Add a seasonal component with specified period, number of Fourier
    components, and prior scale.
    
    Increasing the number of Fourier components allows the seasonality to
    change more quickly (at risk of overfitting). Default values for yearly
    and weekly seasonalities are 10 and 3 respectively.
    
    Increasing prior scale will allow this seasonality component more
    flexibility, decreasing will dampen it. If not provided, will use the
    seasonality_prior_scale provided on Prophet initialization (defaults
    to 10).
    
    Mode can be specified as either 'additive' or 'multiplicative'. If not
    specified, self.seasonality_mode will be used (defaults to additive).
    Additive means the seasonality will be added to the trend,
    multiplicative means it will multiply the trend.
    
    If condition_name is provided, the dataframe passed to `fit` and `predict`
    should have a column with the specified condition_name containing booleans
    which decides when to apply seasonality.
    
    Parameters
    ----------
    name: string name of the seasonality component.
    period: float number of days in one period.
    fourier_order: int number of Fourier components to use.
    prior_scale: optional float prior scale for this component.
    mode: optional 'additive' or 'multiplicative'
    condition_name: string name of the seasonality condition.
    
    Returns
    -------
    The prophet object.

construct_holiday_dataframe(self, dates)
    Construct a dataframe of holiday dates.
    
    Will combine self.holidays with the built-in country holidays
    corresponding to input dates, if self.country_holidays is set.
    
    Parameters
    ----------
    dates: pd.Series containing timestamps used for computing seasonality.
    
    Returns
    -------
    dataframe of holiday dates, in holiday dataframe format used in
    initialization.

fit(self, df, **kwargs)
    Fit the Prophet model.
    
    This sets self.params to contain the fitted model parameters. It is a
    dictionary parameter names as keys and the following items:
        k (Mx1 array): M posterior samples of the initial slope.
        m (Mx1 array): The initial intercept.
        delta (MxN array): The slope change at each of N changepoints.
        beta (MxK matrix): Coefficients for K seasonality features.
        sigma_obs (Mx1 array): Noise level.
    Note that M=1 if MAP estimation.
    
    Parameters
    ----------
    df: pd.DataFrame containing the history. Must have columns ds (date
        type) and y, the time series. If self.growth is 'logistic', then
        df must also have a column cap that specifies the capacity at
        each ds.
    kwargs: Additional arguments passed to the optimizing or sampling
        functions in Stan.
    
    Returns
    -------
    The fitted Prophet object.

initialize_scales(self, initialize_scales, df)
    Initialize model scales.
    
    Sets model scaling factors using df.
    
    Parameters
    ----------
    initialize_scales: Boolean set the scales or not.
    df: pd.DataFrame for setting scales.

make_all_seasonality_features(self, df)
    Dataframe with seasonality features.
    
    Includes seasonality features, holiday features, and added regressors.
    
    Parameters
    ----------
    df: pd.DataFrame with dates for computing seasonality features and any
        added regressors.
    
    Returns
    -------
    pd.DataFrame with regression features.
    list of prior scales for each column of the features dataframe.
    Dataframe with indicators for which regression components correspond to
        which columns.
    Dictionary with keys 'additive' and 'multiplicative' listing the
        component names for each mode of seasonality.

make_future_dataframe(self, periods, freq='D', include_history=True)
    Simulate the trend using the extrapolated generative model.
    
    Parameters
    ----------
    periods: Int number of periods to forecast forward.
    freq: Any valid frequency for pd.date_range, such as 'D' or 'M'.
    include_history: Boolean to include the historical dates in the data
        frame for predictions.
    
    Returns
    -------
    pd.Dataframe that extends forward from the end of self.history for the
    requested number of periods.

make_holiday_features(self, dates, holidays)
    Construct a dataframe of holiday features.
    
    Parameters
    ----------
    dates: pd.Series containing timestamps used for computing seasonality.
    holidays: pd.Dataframe containing holidays, as returned by
        construct_holiday_dataframe.
    
    Returns
    -------
    holiday_features: pd.DataFrame with a column for each holiday.
    prior_scale_list: List of prior scales for each holiday column.
    holiday_names: List of names of holidays

parse_seasonality_args(self, name, arg, auto_disable, default_order)
    Get number of fourier components for built-in seasonalities.
    
    Parameters
    ----------
    name: string name of the seasonality component.
    arg: 'auto', True, False, or number of fourier components as provided.
    auto_disable: bool if seasonality should be disabled when 'auto'.
    default_order: int default fourier order
    
    Returns
    -------
    Number of fourier components, or 0 for disabled.

plot(self, fcst, ax=None, uncertainty=True, plot_cap=True, xlabel='ds', ylabel='y')
    Plot the Prophet forecast.
    
    Parameters
    ----------
    fcst: pd.DataFrame output of self.predict.
    ax: Optional matplotlib axes on which to plot.
    uncertainty: Optional boolean to plot uncertainty intervals.
    plot_cap: Optional boolean indicating if the capacity should be shown
        in the figure, if available.
    xlabel: Optional label name on X-axis
    ylabel: Optional label name on Y-axis
    
    Returns
    -------
    A matplotlib figure.

plot_components(self, fcst, uncertainty=True, plot_cap=True, weekly_start=0, yearly_start=0)
    Plot the Prophet forecast components.
    
    Will plot whichever are available of: trend, holidays, weekly
    seasonality, and yearly seasonality.
    
    Parameters
    ----------
    fcst: pd.DataFrame output of self.predict.
    uncertainty: Optional boolean to plot uncertainty intervals.
    plot_cap: Optional boolean indicating if the capacity should be shown
        in the figure, if available.
    weekly_start: Optional int specifying the start day of the weekly
        seasonality plot. 0 (default) starts the week on Sunday. 1 shifts
        by 1 day to Monday, and so on.
    yearly_start: Optional int specifying the start day of the yearly
        seasonality plot. 0 (default) starts the year on Jan 1. 1 shifts
        by 1 day to Jan 2, and so on.
    
    Returns
    -------
    A matplotlib figure.

predict(self, df=None)
    Predict using the prophet model.
    
    Parameters
    ----------
    df: pd.DataFrame with dates for predictions (column ds), and capacity
        (column cap) if logistic growth. If not provided, predictions are
        made on the history.
    
    Returns
    -------
    A pd.DataFrame with the forecast components.

predict_seasonal_components(self, df)
    Predict seasonality components, holidays, and added regressors.
    
    Parameters
    ----------
    df: Prediction dataframe.
    
    Returns
    -------
    Dataframe with seasonal components.

predict_trend(self, df)
    Predict trend using the prophet model.
    
    Parameters
    ----------
    df: Prediction dataframe.
    
    Returns
    -------
    Vector with trend on prediction dates.

predict_uncertainty(self, df)
    Prediction intervals for yhat and trend.
    
    Parameters
    ----------
    df: Prediction dataframe.
    
    Returns
    -------
    Dataframe with uncertainty intervals.

predictive_samples(self, df)
    Sample from the posterior predictive distribution.
    
    Parameters
    ----------
    df: Dataframe with dates for predictions (column ds), and capacity
        (column cap) if logistic growth.
    
    Returns
    -------
    Dictionary with keys "trend" and "yhat" containing
    posterior predictive samples for that component.

regressor_column_matrix(self, seasonal_features, modes)
    Dataframe indicating which columns of the feature matrix correspond
    to which seasonality/regressor components.
    
    Includes combination components, like 'additive_terms'. These
    combination components will be added to the 'modes' input.
    
    Parameters
    ----------
    seasonal_features: Constructed seasonal features dataframe
    modes: Dictionary with keys 'additive' and 'multiplicative' listing the
        component names for each mode of seasonality.
    
    Returns
    -------
    component_cols: A binary indicator dataframe with columns seasonal
        components and rows columns in seasonal_features. Entry is 1 if
        that columns is used in that component.
    modes: Updated input with combination components.

sample_model(self, df, seasonal_features, iteration, s_a, s_m)
    Simulate observations from the extrapolated generative model.
    
    Parameters
    ----------
    df: Prediction dataframe.
    seasonal_features: pd.DataFrame of seasonal features.
    iteration: Int sampling iteration to use parameters from.
    s_a: Indicator vector for additive components
    s_m: Indicator vector for multiplicative components
    
    Returns
    -------
    Dataframe with trend and yhat, each like df['t'].

sample_posterior_predictive(self, df)
    Prophet posterior predictive samples.
    
    Parameters
    ----------
    df: Prediction dataframe.
    
    Returns
    -------
    Dictionary with posterior predictive samples for the forecast yhat and
    for the trend component.

sample_predictive_trend(self, df, iteration)
    Simulate the trend using the extrapolated generative model.
    
    Parameters
    ----------
    df: Prediction dataframe.
    iteration: Int sampling iteration to use parameters from.
    
    Returns
    -------
    np.array of simulated trend over df['t'].

set_auto_seasonalities(self)
    Set seasonalities that were left on auto.
    
    Turns on yearly seasonality if there is >=2 years of history.
    Turns on weekly seasonality if there is >=2 weeks of history, and the
    spacing between dates in the history is <7 days.
    Turns on daily seasonality if there is >=2 days of history, and the
    spacing between dates in the history is <1 day.

set_changepoints(self)
    Set changepoints
    
    Sets m$changepoints to the dates of changepoints. Either:
    1) The changepoints were passed in explicitly.
        A) They are empty.
        B) They are not empty, and need validation.
    2) We are generating a grid of them.
    3) The user prefers no changepoints be used.

setup_dataframe(self, df, initialize_scales=False)
    Prepare dataframe for fitting or predicting.
    
    Adds a time index and scales y. Creates auxiliary columns 't', 't_ix',
    'y_scaled', and 'cap_scaled'. These columns are used during both
    fitting and predicting.
    
    Parameters
    ----------
    df: pd.DataFrame with columns ds, y, and cap if logistic growth. Any
        specified additional regressors must also be present.
    initialize_scales: Boolean set scaling factors in self from df.
    
    Returns
    -------
    pd.DataFrame prepared for fitting or predicting.

validate_column_name(self, name, check_holidays=True, check_seasonalities=True, check_regressors=True)
    Validates the name of a seasonality, holiday, or regressor.
    
    Parameters
    ----------
    name: string
    check_holidays: bool check if name already used for holiday
    check_seasonalities: bool check if name already used for seasonality
    check_regressors: bool check if name already used for regressor

validate_inputs(self)
    Validates the inputs to Prophet.

----------------------------------------------------------------------
Class methods defined here:

make_seasonality_features(dates, period, series_order, prefix) from builtins.type
    Data frame with seasonality features.
    
    Parameters
    ----------
    cls: Prophet class.
    dates: pd.Series containing timestamps.
    period: Number of days of the period.
    series_order: Number of components.
    prefix: Column name prefix.
    
    Returns
    -------
    pd.DataFrame with seasonality features.

----------------------------------------------------------------------
Static methods defined here:

fourier_series(dates, period, series_order)
    Provides Fourier series components with the specified frequency
    and order.
    
    Parameters
    ----------
    dates: pd.Series containing timestamps.
    period: Number of days of the period.
    series_order: Number of components.
    
    Returns
    -------
    Matrix with seasonality features.

linear_growth_init(df)
    Initialize linear growth.
    
    Provides a strong initialization for linear growth by calculating the
    growth and offset parameters that pass the function through the first
    and last points in the time series.
    
    Parameters
    ----------
    df: pd.DataFrame with columns ds (date), y_scaled (scaled time series),
        and t (scaled time).
    
    Returns
    -------
    A tuple (k, m) with the rate (k) and offset (m) of the linear growth
    function.

logistic_growth_init(df)
    Initialize logistic growth.
    
    Provides a strong initialization for logistic growth by calculating the
    growth and offset parameters that pass the function through the first
    and last points in the time series.
    
    Parameters
    ----------
    df: pd.DataFrame with columns ds (date), cap_scaled (scaled capacity),
        y_scaled (scaled time series), and t (scaled time).
    
    Returns
    -------
    A tuple (k, m) with the rate (k) and offset (m) of the logistic growth
    function.

piecewise_linear(t, deltas, k, m, changepoint_ts)
    Evaluate the piecewise linear function.
    
    Parameters
    ----------
    t: np.array of times on which the function is evaluated.
    deltas: np.array of rate changes at each changepoint.
    k: Float initial rate.
    m: Float initial offset.
    changepoint_ts: np.array of changepoint times.
    
    Returns
    -------
    Vector y(t).

piecewise_logistic(t, cap, deltas, k, m, changepoint_ts)
    Evaluate the piecewise logistic function.
    
    Parameters
    ----------
    t: np.array of times on which the function is evaluated.
    cap: np.array of capacities at each t.
    deltas: np.array of rate changes at each changepoint.
    k: Float initial rate.
    m: Float initial offset.
    changepoint_ts: np.array of changepoint times.
    
    Returns
    -------
    Vector y(t).

----------------------------------------------------------------------
Data descriptors defined here:

__dict__
    dictionary for instance variables (if defined)

__weakref__
    list of weak references to the object (if defined)