def test_seasonality_modes(self):
# Model with holidays, seasonalities, and extra regressors
holidays = pd.DataFrame({
'ds': pd.to_datetime(['2016-12-25']),
'holiday': ['xmas'],
'lower_window': [-1],
'upper_window': [0],
})
m = Prophet(seasonality_mode='multiplicative', holidays=holidays)
m.add_seasonality('monthly', period=30, mode='additive', fourier_order=3)
m.add_regressor('binary_feature', mode='additive')
m.add_regressor('numeric_feature')
# Construct seasonal features
df = DATA.copy()
df['binary_feature'] = [0] * 255 + [1] * 255
df['numeric_feature'] = range(510)
df = m.setup_dataframe(df, initialize_scales=True)
m.history = df.copy()
m.set_auto_seasonalities()
seasonal_features, prior_scales, component_cols, modes = (
m.make_all_seasonality_features(df))
self.assertEqual(sum(component_cols['additive_terms']), 7)
self.assertEqual(sum(component_cols['multiplicative_terms']), 29)
self.assertEqual(
set(modes['additive']),
{'monthly', 'binary_feature', 'additive_terms',
'extra_regressors_additive'},
)
self.assertEqual(
set(modes['multiplicative']),
{'weekly', 'yearly', 'xmas', 'numeric_feature',
'multiplicative_terms', 'extra_regressors_multiplicative',
'holidays',
},
)
def build_model_with_holidays(self, data, seasonality, holidays):
model=Prophet(growth='logistic',\
interval_width=0.95,\
n_changepoints=8,\
changepoint_prior_scale=0.7,\
holidays=holidays)
model.add_seasonality(name='hourly', period=8, fourier_order=7)
model.fit(data)
return model
def test_custom_seasonality(self):
holidays = pd.DataFrame({
'ds': pd.to_datetime(['2017-01-02']),
'holiday': ['special_day'],
'prior_scale': [4.],
})
m = Prophet(holidays=holidays)
m.add_seasonality(name='monthly',
period=30,
fourier_order=5,
prior_scale=2.)
self.assertEqual(
m.seasonalities['monthly'],
{
'period': 30,
'fourier_order': 5,
'prior_scale': 2.,
'mode': 'additive',
'condition_name': None
},
)
with self.assertRaises(ValueError):
m.add_seasonality(name='special_day', period=30, fourier_order=5)
with self.assertRaises(ValueError):
m.add_seasonality(name='trend', period=30, fourier_order=5)
m.add_seasonality(name='weekly', period=30, fourier_order=5)
# Test priors
m = Prophet(
holidays=holidays,
yearly_seasonality=False,
seasonality_mode='multiplicative',
)
m.add_seasonality(name='monthly',
period=30,
fourier_order=5,
prior_scale=2.,
mode='additive')
m.fit(DATA.copy())
self.assertEqual(m.seasonalities['monthly']['mode'], 'additive')
self.assertEqual(m.seasonalities['weekly']['mode'], 'multiplicative')
seasonal_features, prior_scales, component_cols, modes = (
m.make_all_seasonality_features(m.history))
self.assertEqual(sum(component_cols['monthly']), 10)
self.assertEqual(sum(component_cols['special_day']), 1)
self.assertEqual(sum(component_cols['weekly']), 6)
self.assertEqual(sum(component_cols['additive_terms']), 10)
self.assertEqual(sum(component_cols['multiplicative_terms']), 7)
if seasonal_features.columns[0] == 'monthly_delim_1':
true = [2.] * 10 + [10.] * 6 + [4.]
self.assertEqual(sum(component_cols['monthly'][:10]), 10)
self.assertEqual(sum(component_cols['weekly'][10:16]), 6)
else:
true = [10.] * 6 + [2.] * 10 + [4.]
self.assertEqual(sum(component_cols['weekly'][:6]), 6)
self.assertEqual(sum(component_cols['monthly'][6:16]), 10)
self.assertEqual(prior_scales, true)
def get_list_of_prices(stock_list, num_of_months):
df = pd.read_csv('../data/stock_data.csv')
count = 1
list_of_prices = []
for stock in stock_list:
list_of_projected = {}
stock_data = df.iloc[:, count:count + 7]
count += 7
col_indices = [0, 1]
new_names = ['ds', 'y']
old_names = stock_data.columns[col_indices]
stock_data.rename(columns=dict(zip(old_names, new_names)),
inplace=True)
stock_data = stock_data.filter(items=['ds', 'y'])
model = Prophet(daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=True,
changepoint_prior_scale=0.05,
changepoints=None)
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
model.fit(stock_data)
pkl_path = "../models/" + stock + ".pkl"
with open(pkl_path, "wb") as f:
# Pickle the 'Prophet' model using the highest protocol available.
pickle.dump(model, f)
#makes prediction one year in advance
future_data = model.make_future_dataframe(
periods=((num_of_months + 1) * 30))
forecast = model.predict(future_data)
forecasted_price = forecast[['ds', 'yhat']]
print(forecasted_price)
#start = datetime.datetime.strptime("Dec 1 2019", '%b %d %Y')
today = datetime.datetime.now()
#diff_months = (today.year - start.year) * 12 + (today.month - start.month)
#num_of_months += diff_months
for i in range(num_of_months):
future = today + relativedelta(months=i + 1)
#tfuture_df = future
tfuture = future.strftime("%Y-%m-01")
#print(type(forecasted_price[forecasted_price['ds'] == tfuture]))
# while (forecasted_price[forecasted_price['ds'] == tfuture].empty):
# tfuture_df = tfuture_df + relativedelta(days=1)
# tfuture = tfuture_df.strftime("%Y-%m-%d")
#print(tfuture)
# print(forecasted_price[forecasted_price['ds'] == tfuture])
value = forecasted_price[forecasted_price['ds'] ==
tfuture].values[0][1]
future = future.strftime("%m-01-%Y")
future += ' GMT'
list_of_projected[future] = value
list_of_prices.append(list_of_projected)
#forecasted_price.to_csv('future_data.csv')
return list_of_prices
def Bayseian2(txs_raw, forecastDay, y, x_col, unit):
txs_raw = copy.deepcopy(txs_raw.rename(index=str, columns={y: 'y'}))
txs_train, txs_test = ft_c.cut_df(
txs_raw, varr.START_DATE,
(varr.LAST_DATE - timedelta(days=forecastDay - 1)))
txs_trainX, txs_trainY = txs_train[x_col], txs_train['y']
txs_testX, txs_testY = txs_test[x_col], txs_test['y']
# print(txs_train.tail())
# print(txs_testX.head())
# print(txs_testY.tail())
# seasonality_option: (daily, weekly, monthly, yearly, frequency)
if unit is 'day':
if (len(txs_train) < 366):
seasonality_option = (False, True, True, False, 'd')
else:
seasonality_option = (False, True, True, True, 'd')
elif unit is 'week':
if (len(txs_train) < 53):
seasonality_option = (False, False, True, False, 'w')
else:
seasonality_option = (False, False, True, True, 'w')
elif unit is 'month':
if (len(txs_train) < 12):
seasonality_option = (False, False, False, False, 'm')
else:
seasonality_option = (False, False, False, True, 'm')
model = Prophet(daily_seasonality= seasonality_option[0],
yearly_seasonality=seasonality_option[3], \
holidays= holidaybeta)
if seasonality_option[2]:
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
if seasonality_option[1]:
model.add_seasonality(name='weekly',
period=7,
fourier_order=5,
prior_scale=0.1)
for feature in x_col:
if not feature == 'ds': model.add_regressor(feature)
model.fit(txs_train)
#future= txs_raw[['ds', 'rain_amount', 'temp_max', 'temp_min']]
future = pd.concat([txs_trainX, txs_testX], axis=0)
# future['ds']= pd.to_datetime(future['ds'], format= "%Y-%m-%d")
#
# print(future[future.isnull().any(axis=1)])
# print(future)
forecastProphetTable = model.predict(future)
return {'model': model, 'future': future, \
'forecastProphetTable': forecastProphetTable}
def define_model(self):
model_object = Prophet(changepoint_prior_scale=self.model_parameters['changepoint_prior_scale'],
seasonality_mode=self.model_parameters['seasonality_mode'],
yearly_seasonality=False,
weekly_seasonality=False,
daily_seasonality=False)
if 'seasonality' in self.model_parameters:
for season in self.model_parameters['seasonality']:
model_object.add_seasonality(name=season, **self.model_parameters['seasonality'][season])
return model_object
def build_model(params, state, verbose = True):
if params['holiday']:
holiday_df = get_holidays(state = state)
if holiday_df is not None:
if verbose: print('initializing model with downloaded holidays!')
m = Prophet(daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
changepoint_prior_scale=params.get('changepoint_prior_scale', 0.05),
holidays=holiday_df,
holidays_prior_scale=params.get('holidays_prior_scale', 10),
interval_width=0.95)
else:
if verbose: print('using in-built holidays!')
m = Prophet(daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
changepoint_prior_scale=params.get('changepoint_prior_scale', 0.05),
holidays_prior_scale=params.get('holidays_prior_scale', 10),
interval_width=0.95)
m.add_country_holidays(country_name='IN')
else:
m = Prophet(
daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
changepoint_prior_scale=params.get('changepoint_prior_scale', 0.05),
interval_width=0.95
)
if 'seasonal' in params.keys():
if 'yearly' in params['seasonal'].keys():
if verbose: print('using yearly seasonality')
period, fourier_order, prior_scale, mode = params['seasonal']['yearly']
m.add_seasonality(name = 'yearly', period = period, fourier_order = fourier_order, prior_scale = prior_scale, mode = mode)
if 'quarterly' in params['seasonal'].keys():
if verbose: print('using quarterly seasonality')
period, fourier_order, prior_scale, mode = params['seasonal']['quarterly']
m.add_seasonality(name = 'quarterly', period = period, fourier_order = fourier_order, prior_scale = prior_scale, mode = mode)
if 'monthly' in params['seasonal'].keys():
if verbose: print('using monthly seasonality')
period, fourier_order, prior_scale, mode = params['seasonal']['monthly']
m.add_seasonality(name = 'monthly', period = period, fourier_order = fourier_order, prior_scale = prior_scale, mode = mode)
if 'weekly' in params['seasonal'].keys():
if verbose: print('using weekly seasonality')
period, fourier_order, prior_scale, mode = params['seasonal']['weekly']
m.add_seasonality(name = 'weekly', period = period, fourier_order = fourier_order, prior_scale = prior_scale, mode= mode)
if 'daily' in params['seasonal'].keys():
if verbose: print('using daily seasonality')
period, fourier_order, prior_scale, mode = params['seasonal']['daily']
m.add_seasonality(name = 'daily', period = period, fourier_order = fourier_order, prior_scale = prior_scale, mode= mode)
return m
def get_prophet_forecasting(group_name, group, cap=None):
data = group.reset_index()
data.columns = ['ds', 'y']
data['y'][data.y <= 0] = 0.0
# Remove first null rows
first_row = 0
for i in range(len(data)):
if data.y[i] == 0:
first_row = i+1
else:
break
data = data.loc[first_row:, :]
data['y'][data.y > 0] = np.log(data['y'][data.y > 0])
if len(data) == 0:
# frcst = forecastings[-1][1]
# frcst['yhat'] = 0
return [group_name[0], group_name[1], np.zeros(12)], [None, None]
with suppress_stdout_stderr():
try:
m = Prophet(growth='logistic', weekly_seasonality=False, daily_seasonality=False)
m.add_seasonality(name='monthly', period=30.5, fourier_order=5)
cap = max(data.y)
data['cap'] = cap
m.fit(data)
future = m.make_future_dataframe(periods=1*12, freq='M')
future['cap'] = cap
frcst = m.predict(future);
except:
return [group_name[0], group_name[1], np.zeros(12)], [None, None]
# for field in ['yhat', 'yhat_lower', 'yhat_upper']:
# print('---- ',list(frcst[frcst[field] > 0][field]))
# print(sum(frcst[field] > 0))
# frcst.loc[frcst[field] > 0][field] = np.exp(list(frcst.loc[frcst[field] > 0][field].values))
# print('*****', list(frcst[frcst[field] > 0][field]))
# print(np.exp([2.02]))
#
return [group_name[0], group_name[1], np.exp(frcst['yhat'].values)], [m, frcst]
def prophet(train, test, t=132):
df = pd.DataFrame(data={"ds": train.index, "y": train.values.reshape(-1)})
m = Prophet()
m.add_seasonality(name='11yr', period=365.25 * 11, fourier_order=5)
m.fit(df)
# predict a cycle
future = m.make_future_dataframe(periods=t)
forecast = m.predict(future)
y_pred = forecast['yhat'][-t:]
rmse = error(test.values, y_pred)
return [m, forecast], y_pred, rmse
def forecast(series, val_dates, holidays, weekly=0, monthly=0, cpoint=0.05):
"""
Parameters
----------
series : dataframe
DESCRIPTION.
val_dates : dataframe
'ds' - dates for forecasting
holidays : dataframe, follows Propher requirements
DESCRIPTION.
weekly : integer, optional
DESCRIPTION. The default is 0.
monthly : integer, optional
DESCRIPTION. The default is 0.
cpoint : float, optional
DESCRIPTION. The default is 0.05.
Returns
-------
model : TYPE
DESCRIPTION.
"""
series = series.copy()
val_dates = val_dates.copy()
#define model
modelf = Prophet(interval_width=0.95,
daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
holidays=holidays,
changepoint_prior_scale=cpoint)
if weekly != 0:
modelf.add_seasonality(name='weeklyx', period=7, fourier_order=weekly)
if monthly != 0:
modelf.add_seasonality(name='monthlyx',
period=30.5,
fourier_order=monthly)
modelf.fit(series)
val_dates['yhat'] = modelf.predict(val_dates[['ds'
]]).yhat.values.clip(min=0)
val_dates['pred_date'] = series.tail(1).ds.dt.date.values.tolist()[0]
val_dates['pred_day'] = [
'day ' + str(i) for i in range(val_dates.shape[0])
]
return model
def train(self):
"""Method to train Prophet forecaster
"""
model = Prophet(
growth=self.growth,
changepoints=self.changepoints,
n_changepoints=self.n_changepoints,
changepoint_range=self.changepoint_range,
yearly_seasonality=self.yearly_seasonality,
weekly_seasonality=self.weekly_seasonality,
daily_seasonality=self.daily_seasonality,
# holidays is not used directly from config, it's processed in make_holidays_data
holidays=self.holidays_data,
seasonality_mode=self.seasonality_mode,
seasonality_prior_scale=self.seasonality_prior_scale,
holidays_prior_scale=self.holidays_prior_scale,
changepoint_prior_scale=self.changepoint_prior_scale,
mcmc_samples=self.mcmc_samples,
interval_width=self.interval_width,
uncertainty_samples=self.uncertainty_samples,
stan_backend=self.stan_backend,
)
if self.country_holidays is not None:
model.add_country_holidays(country_name=self.country_holidays)
LOGGER.info(
f"Add built-in country holidays {self.country_holidays}")
if self.custom_seasonalities is not None:
kwargs = [
"name",
"period",
"fourier_order",
"prior_scale",
"mode",
"condition_name",
]
for s in self.custom_seasonalities:
model.add_seasonality(
**{k: v
for k, v in s.items() if k in kwargs})
LOGGER.info(
f"Add custom seasonalities {self.custom_seasonalities}")
model.fit(self.data)
if self.model_uri is not None:
self.save(model, "model_uri", ftype="pickle")
LOGGER.info(f"Model object saved to {self.model_uri}")
self.model = model
def _fit_and_predict(self):
"""
creates the prophet model and casts predictions based on the self.train
and self.test data. Saves results to a Pandas DataFrame.
"""
with suppress_stdout_stderr():
model = Prophet(daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=False,
changepoint_prior_scale=.05)
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
model.fit(self.labels)
future = model.make_future_dataframe(periods=self.days)
self.forecast = model.predict(future)
def seasonal_daily_prophet_model(df):
model = Prophet(
daily_seasonality=False,
yearly_seasonality=20,
changepoint_prior_scale=0.001
)
model.add_seasonality(
name='winter_weekday',
period=1,
fourier_order=12,
condition_name='winter_weekday'
)
model.add_seasonality(
name='winter_weekend',
period=1,
fourier_order=12,
condition_name='winter_weekend'
)
model.add_seasonality(
name='summer_weekday',
period=1,
fourier_order=12,
condition_name='summer_weekday'
)
model.add_seasonality(
name='summer_weekend',
period=1,
fourier_order=12,
condition_name='summer_weekend'
)
model.add_country_holidays(country_name='US')
df = add_season_weekday_indicators(df)
model.fit(df)
return model
def test_custom_seasonality(self):
holidays = pd.DataFrame({
'ds': pd.to_datetime(['2017-01-02']),
'holiday': ['special_day'],
'prior_scale': [4.],
})
m = Prophet(holidays=holidays)
m.add_seasonality(name='monthly', period=30, fourier_order=5,
prior_scale=2.)
self.assertEqual(
m.seasonalities['monthly'],
{
'period': 30,
'fourier_order': 5,
'prior_scale': 2.,
'mode': 'additive',
},
)
with self.assertRaises(ValueError):
m.add_seasonality(name='special_day', period=30, fourier_order=5)
with self.assertRaises(ValueError):
m.add_seasonality(name='trend', period=30, fourier_order=5)
m.add_seasonality(name='weekly', period=30, fourier_order=5)
# Test priors
m = Prophet(
holidays=holidays, yearly_seasonality=False,
seasonality_mode='multiplicative',
)
m.add_seasonality(name='monthly', period=30, fourier_order=5,
prior_scale=2., mode='additive')
m.fit(DATA.copy())
self.assertEqual(m.seasonalities['monthly']['mode'], 'additive')
self.assertEqual(m.seasonalities['weekly']['mode'], 'multiplicative')
seasonal_features, prior_scales, component_cols, modes = (
m.make_all_seasonality_features(m.history)
)
self.assertEqual(sum(component_cols['monthly']), 10)
self.assertEqual(sum(component_cols['special_day']), 1)
self.assertEqual(sum(component_cols['weekly']), 6)
self.assertEqual(sum(component_cols['additive_terms']), 10)
self.assertEqual(sum(component_cols['multiplicative_terms']), 7)
if seasonal_features.columns[0] == 'monthly_delim_1':
true = [2.] * 10 + [10.] * 6 + [4.]
self.assertEqual(sum(component_cols['monthly'][:10]), 10)
self.assertEqual(sum(component_cols['weekly'][10:16]), 6)
else:
true = [10.] * 6 + [2.] * 10 + [4.]
self.assertEqual(sum(component_cols['weekly'][:6]), 6)
self.assertEqual(sum(component_cols['monthly'][6:16]), 10)
self.assertEqual(prior_scales, true)
def prophet_f(daily_prior, yearly_prior, hum_prior, dp_prior, metric = 'rmse', period = '1000 hours'):
"""
Implements the prophet model to be optimised and performs cross-validation
Args:
daily_prior: daily seasonality prior scale
yearly_prior: yearly seasonality prior scale
hum_prior: humidity regressor prior scale
dp_prior: dew.point regressor prior scale
metric: metric(s) to return - 'rmse' or ['horizon', 'rmse', 'mae', 'mape']
period: cross-validation period
Returns:
negative of root mean square error
"""
m = Prophet(growth = 'flat',
weekly_seasonality = False)
m.add_seasonality(name = 'daily',
period = 1,
mode = 'multiplicative',
prior_scale = 10 ** daily_prior,
fourier_order = 2)
m.add_seasonality(name = 'yearly',
period = 365.25,
mode = 'additive',
prior_scale = 10 ** yearly_prior,
fourier_order = 2)
m.add_regressor('humidity',
mode = 'multiplicative',
prior_scale = 10 ** hum_prior)
m.add_regressor('dew.point',
mode = 'multiplicative',
prior_scale = 10 ** dp_prior)
m.fit(df)
df_cv = cross_validation(m,
initial = '90000 hours',
period = period,
horizon = '1 hours')
if metric == 'rmse':
df_cv_rmse = ((df_cv.y - df_cv.yhat) ** 2).mean() ** .5
return - df_cv_rmse
elif metric == 'all':
df_p = performance_metrics(df_cv)
return m, df_p[['horizon', 'rmse', 'mae', 'mape']]
def create_model():
model = Prophet(weekly_seasonality=True,
yearly_seasonality=True,
changepoint_prior_scale=0.2,
changepoint_range=0.9) #instantiate Prophet
# Add monthly seasonality
model.add_seasonality(name='monthly',
period=30.5,
fourier_order=8,
mode='additive')
model.add_seasonality('quarterly',
period=91.25,
fourier_order=8,
mode='additive')
return model
def _fit(self):
X = self.stock.index
y = self.stock.Close
train = pd.DataFrame()
train['y'] = y.values
train['ds'] = X.values
with suppress_stdout_stderr():
model = Prophet(daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=True,
changepoint_prior_scale=.05)
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
model.fit(train)
future = model.make_future_dataframe(periods=self.days_predict)
self.forecast = model.predict(future)
def evaluate_prophet_configuration(upc: int,
config: list,
base_df: pd.DataFrame,
holidays: pd.DataFrame = None) -> dict:
"""
Runs and evaluates specified Prophet configuration.
:param upc:
:param config:
:param base_df:
:param holidays:
:return:
"""
# Split in train and test set.
split_date = base_df.max()["ds"] - pd.Timedelta(4, unit='w')
train_set = base_df[base_df.ds <= split_date]
test_set = base_df[base_df.ds > split_date]
with suppress_stdout_stderr():
proph = Prophet(yearly_seasonality=config[0],
weekly_seasonality=config[2],
daily_seasonality=config[3],
seasonality_mode=config[4],
n_changepoints=config[5],
holidays=holidays)
if config[1]:
proph.add_seasonality(name='monthly', period=30.5, fourier_order=3)
proph.fit(train_set)
future = proph.make_future_dataframe(periods=4, freq="W")
# Return configuration + MSE result.
return {
"UPC":
upc,
"yearly_seasonality":
config[0],
"monthly_seasonality":
config[1],
"weekly_seasonality":
config[2],
"daily_seasonality":
config[3],
"seasonality_mode":
config[4],
"n_changepoints":
config[5],
"MSE":
np.mean(np.power(test_set.y - proph.predict(future).yhat.tail(4), 2))
}
def fitAndPred(
self,
train_data,
yearly_seasonality='auto',
weekly_seasonality=False,
seasonality_mode='additive', # multiplicative | additive
changepoint_prior_scale=0.04, # default: 0.05
changepoint_range=0.85, # default: 0.8
seasonality_prior_scale=10.0, # default: 10.0
growth='linear',
interval_width=0.80,
changepoints=None,
monthly_seasonality=False):
# train_data['floor'] = floor
# train_data['cap'] = cap
pf_model = Prophet(
yearly_seasonality=yearly_seasonality,
weekly_seasonality=weekly_seasonality,
seasonality_mode=seasonality_mode, # multiplicative | additive
changepoint_prior_scale=changepoint_prior_scale, # default: 0.05
changepoint_range=changepoint_range, # default: 0.8
seasonality_prior_scale=seasonality_prior_scale, # default: 10.0
growth=growth,
interval_width=interval_width,
changepoints=changepoints) # , mcmc_samples=300)
dict_ = {'ds': train_data.index, 'y': train_data.values}
_train_data = pd.DataFrame(dict_)
if monthly_seasonality:
pf_model.add_seasonality(name='monthly',
period=30.5,
fourier_order=5)
if growth == 'logistic':
_train_data['cap'] = max(_train_data[['y']].values)[0]
#pf_model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
pf_model.fit(_train_data)
_future = pf_model.make_future_dataframe(periods=self.num_preds,
freq=self.freq)
_future['cap'] = max(_train_data[['y']].values)[0]
_forecast = pf_model.predict(_future)
else:
pf_model.fit(_train_data)
_future = pf_model.make_future_dataframe(periods=self.num_preds,
freq=self.freq)
_forecast = pf_model.predict(_future)
forecast = _forecast['yhat'].values
#print(forecast[[column_ds, 'yhat', 'yhat_lower', 'yhat_upper']].tail(5))
return forecast
def background_predict(regions_read_sequence):
log_file = open("predict_log_file.txt", "a")
for region_id, region_seq in regions_read_sequence.items():
if len(region_seq.index) < 2:
continue
s1 = True
for c in region_seq['y']:
if int(c) >= 500000:
s1 = False
if s1:
continue
# add seasonality manually
m = Prophet(daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False)
m.add_seasonality(name='hourly',
period=0.010416666665,
fourier_order=10)
m = m.fit(region_seq)
future = m.make_future_dataframe(periods=60, freq='1min')
fcst = m.predict(future).tail(60)
log_file.write(str((region_id, fcst['yhat'], fcst['trend'])) + '\n')
log_file.flush()
access_cnts = [
sum(fcst['yhat'][i:i + 5]) - sum(fcst['trend'][i:i + 5])
for i in range(0, 60, 5)
]
ind = list(
map(lambda x: x[0] * 5,
filter(lambda x: x[1] >= 0, enumerate(access_cnts))))
current_time = datetime.datetime.now()
predict_time = [(fcst['ds'].iloc[i] - current_time).total_seconds()
for i in ind]
for p in predict_time:
t = Thread(target=send_req_timer, args=(
int(p),
region_id,
))
t.start()
log_file.close()
def fbProphet_init(self, regressors, features):
prophet = Prophet(
growth='linear',
daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
changepoint_prior_scale=0.001,
seasonality_mode='additive',
)
# Adding seasonalities
if 'season_summer' in features:
prophet.add_seasonality(
name='summer',
period=6,
fourier_order=2,
condition_name='season_summer')
if 'season_winter' in features:
prophet.add_seasonality(
name='winter',
period=6,
fourier_order=2,
condition_name='season_winter')
prophet.add_seasonality(
name='daily',
period=1,
fourier_order=2,
)
prophet.add_seasonality(
name='weekly',
period=7,
fourier_order=10,
)
prophet.add_seasonality(
name='yearly',
period=366,
fourier_order=20,
)
# Adding external regressors
for reg in regressors:
prophet.add_regressor(reg, prior_scale=20, mode='additive', standardize='auto')
return prophet
def test4():
"""
对节假日和季节性设定先验规模
如果发现节假日效应被过度拟合了，通过设置参数 holidays_prior_scale 可以调整它们的先验规模来使之平滑，
默认下该值取 10 。
seasonality_prior_scale 参数可以用来调整模型对于季节性的拟合程度
"""
m = Prophet(holidays=holidays, holidays_prior_scale=0.05)
# 可以通过在节假日的dataframe中包含一个列prior_scale来单独设置先验规模。
# 独立的季节性的先验规模可以作为add_seasonality的参数传递。例如，可以使用以下方法设置每周季节性的先验规模:
m = Prophet()
m.add_seasonality(name='weekly',
period=7,
fourier_order=3,
prior_scale=0.1)
def test3():
"""
自定义季节性因素
如果时间序列超过两个周期，Prophet将默认适合 每周 和 每年 的季节性
Prophet为周季节性设定的傅立叶order为3，为年季节性设定的为 10。
add_seasality的一个可选输入是该季节性组件的先验规模。
每月的季节性将出现在组件图中
"""
df = pd.read_csv("data/example_wp_log_peyton_manning.csv")
m = Prophet(weekly_seasonality=False)
m.add_seasonality(name='monthly', period=30.5, fourier_order=5)
m.fit(df)
future = m.make_future_dataframe(periods=365)
forecast = m.predict(future)
fig = m.plot_components(forecast)
plt.show()
def _fit_and_predict(self):
"""
creates the prophet model and casts predictions based on the self.train
and self.test data. Saves results to a Pandas DataFrame.
"""
with suppress_stdout_stderr():
model = Prophet(daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=False,
changepoint_prior_scale=.05)
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
model.fit(self.train)
future = pd.DataFrame()
future['ds'] = self.data.index.tz_localize(tz=None).values
self.forecast = model.predict(future)
self.forecast.set_index('ds', inplace=True)
def fit_predict(df_training, holiday, fr, cp, ss, dimPred, frequency):
m = Prophet(holidays=holiday, interval_width=0.99, yearly_seasonality=False, weekly_seasonality=fr[1],
daily_seasonality=False, changepoint_prior_scale=cp, holidays_prior_scale=15,
seasonality_prior_scale=ss, seasonality_mode='multiplicative')
m.add_seasonality(name='work_days', period=1, fourier_order=fr[0], condition_name='no_weekend')
m.add_seasonality(name='weekend_days', period=1, fourier_order=fr[0], condition_name='weekend')
with suppress_stdout_stderr():
m.fit(df_training)
future = m.make_future_dataframe(periods=dimPred, freq=frequency)
future['weekend'] = future['ds'].apply(isWeekendDay)
future['no_weekend'] = ~future['ds'].apply(isWeekendDay)
fcst = m.predict(future)
fcst['yhat'] = fcst['yhat'].apply(noNegative)
fcst['yhat_lower'] = fcst['yhat_lower'].apply(noNegative)
return fcst, m
def get_model(params):
"""
获取模型 主要是交叉验证需要重新训练模型 为了封装方便提取出来
:param params:
:return:
"""
model = Prophet(**params)
# 添加法定节假日
model.add_country_holidays(country_name='CN')
# 每个月月初和月末也不同
# model.add_seasonality(name='two_weeks', period=14, fourier_order=2)
model.add_seasonality(name='monthly', period=30.5, fourier_order=2)
# 添加周二周三效应
# model.add_regressor('if_2_or_3')
# model.add_regressor('if_6_or_7')
return model
def build_model(pars):
wseas, mseas, yseas, s_prior, h_prior, c_prior = pars
m = Prophet(growth='linear',
daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
seasonality_prior_scale=s_prior,
holidays_prior_scale=h_prior,
changepoint_prior_scale=c_prior)
m = m.add_seasonality(name='weekly', period=7, fourier_order=wseas)
m = m.add_seasonality(name='monthly', period=30.5, fourier_order=mseas)
m = m.add_seasonality(name='yearly', period=365.25, fourier_order=yseas)
return m
def test_seasonality_modes(self):
# Model with holidays, seasonalities, and extra regressors
holidays = pd.DataFrame({
'ds': pd.to_datetime(['2016-12-25']),
'holiday': ['xmas'],
'lower_window': [-1],
'upper_window': [0],
})
m = Prophet(seasonality_mode='multiplicative', holidays=holidays)
m.add_seasonality('monthly',
period=30,
mode='additive',
fourier_order=3)
m.add_regressor('binary_feature', mode='additive')
m.add_regressor('numeric_feature')
# Construct seasonal features
df = DATA.copy()
df['binary_feature'] = [0] * 255 + [1] * 255
df['numeric_feature'] = range(510)
df = m.setup_dataframe(df, initialize_scales=True)
m.history = df.copy()
m.set_auto_seasonalities()
seasonal_features, prior_scales, component_cols, modes = (
m.make_all_seasonality_features(df))
self.assertEqual(sum(component_cols['additive_terms']), 7)
self.assertEqual(sum(component_cols['multiplicative_terms']), 29)
self.assertEqual(
set(modes['additive']),
{
'monthly', 'binary_feature', 'additive_terms',
'extra_regressors_additive'
},
)
self.assertEqual(
set(modes['multiplicative']),
{
'weekly',
'yearly',
'xmas',
'numeric_feature',
'multiplicative_terms',
'extra_regressors_multiplicative',
'holidays',
},
)
def createForecast(self, df):
corona_prophet = Prophet(changepoint_prior_scale=0.15,
weekly_seasonality=False,
yearly_seasonality=False)
corona_prophet.add_seasonality('self_define_cycle',
period=8,
fourier_order=8,
mode='additive')
corona_prophet.fit(df)
# Make a future dataframe for 6 months
corona_forecast = corona_prophet.make_future_dataframe(periods=20,
freq='D')
# Make predictions
corona_forecast = corona_prophet.predict(corona_forecast)
corona_forecast.index = corona_forecast['ds']
corona_forecast.drop(['ds'], axis=1, inplace=True)
#corona_forecast = corona_forecast.rename(columns={'yhat':'Open'})
return corona_prophet, corona_forecast
def model_prophet_predict(series, val_dates, holidays, weekly=0, monthly=0):
#define model
modelf = Prophet(interval_width=0.95,
daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=False,
holidays=holidays)
if weekly != 0:
modelf.add_seasonality(name='weeklyx', period=7, fourier_order=weekly)
if monthly != 0:
modelf.add_seasonality(name='monthlyx',
period=30.5,
fourier_order=monthly)
modelf.fit(series)
return modelf, modelf.predict(val_dates)
def test_prph(X_train, X_test, y_train, y_test):
train = pd.DataFrame()
train['ds'] = list(X_train)
train['y'] = list(y_train)
test = pd.DataFrame()
test['ds'] = list(X_test)
test['y'] = list(y_test)
with suppress_stdout_stderr():
model = Prophet(daily_seasonality=False,
weekly_seasonality=False,
yearly_seasonality=True,
changepoint_prior_scale=.05)
model.add_seasonality(name='monthly', period=30.5, fourier_order=5)
model.fit(train)
future = model.make_future_dataframe(periods=261)
forecast = model.predict(future)
return (forecast.yhat.tail(261))
def test_cross_validation_extra_regressors(self):
df = self.__df.copy()
df['extra'] = range(df.shape[0])
m = Prophet()
m.add_seasonality(name='monthly', period=30.5, fourier_order=5)
m.add_regressor('extra')
m.fit(df)
df_cv = diagnostics.cross_validation(
m, horizon='4 days', period='4 days', initial='135 days')
self.assertEqual(len(np.unique(df_cv['cutoff'])), 2)
period = pd.Timedelta('4 days')
dc = df_cv['cutoff'].diff()
dc = dc[dc > pd.Timedelta(0)].min()
self.assertTrue(dc >= period)
self.assertTrue((df_cv['cutoff'] < df_cv['ds']).all())
df_merged = pd.merge(df_cv, self.__df, 'left', on='ds')
self.assertAlmostEqual(
np.sum((df_merged['y_x'] - df_merged['y_y']) ** 2), 0.0)
def getForecastForStoreAndItemPandas(storeNum,
itemNum,
numDays=30,
totalInfo=False,
printSummary=False):
df = getDFofStoreItem(storeNum, itemNum)
#testValue = testDF(storeNum, itemNum)
prophet = Prophet()
prophet.add_seasonality(name='yearly', period=365, fourier_order=10)
prophet.fit(df)
numDays = int(numDays)
future = prophet.make_future_dataframe(periods=numDays)
forecast = prophet.predict(future)
forecast = forecast.rename(columns={
'ds': 'Date',
'yhat': 'Predicted Sales'
})
forecast = forecast.set_index('Date')
pred = forecast.iloc[-numDays:]
if printSummary:
total = int(pred['Predicted Sales'].sum())
margin = int((pred['yhat_upper'].sum() - pred['yhat_lower'].sum()) / 2)
mySummary = 'The projected total sales for Item ' + str(
itemNum) + ' at Store ' + str(storeNum) + ' for ' + str(
numDays) + ' days is about ' + str(
total) + ' with a margin of error of ' + str(margin)
#if not testValue:
#print('These predictions may not be completely accurate')
pred['Predicted Sales'] = pred['Predicted Sales'].astype(int)
pred = pred.drop(columns=[
'multiplicative_terms', 'multiplicative_terms_lower',
'multiplicative_terms_upper'
])
if totalInfo and printSummary:
return pred, mySummary
elif totalInfo and not printSummary:
return pred, ''
elif not totalInfo and printSummary:
return pred['Predicted Sales'], mySummary
else:
return pred['Predicted Sales'], ''
fig = sm.graphics.tsa.plot_pacf(view_hour['distinct_freq_sum'], lags=24, ax=axes[1]) ##acf_pacf() ####################################### ### Beginning of Prophet section ####################################### #%% view_hour['y'] = np.log(view_hour['distinct_freq_sum']) view_hour['ds'] = view_hour['date_hour'] view_hour.head(5) #%% ## Prophet1 # set the uncertainty interval to 95% (the Prophet default is 80%) m = Prophet() m.add_seasonality(name='hourly', period=24, fourier_order=2) m.fit(view_hour); #%% ## Create a dataframe for the future dates ## The tail will only display the time periods without the forecasted values future = m.make_future_dataframe(periods=24,freq='H') future.tail() #%% ## This is the data that is exponentiated below forecast = m.predict(future) forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail() #%%
def test_copy(self):
df = DATA_all.copy()
df['cap'] = 200.
df['binary_feature'] = [0] * 255 + [1] * 255
# These values are created except for its default values
holiday = pd.DataFrame(
{'ds': pd.to_datetime(['2016-12-25']), 'holiday': ['x']})
products = itertools.product(
['linear', 'logistic'], # growth
[None, pd.to_datetime(['2016-12-25'])], # changepoints
[3], # n_changepoints
[0.9], # changepoint_range
[True, False], # yearly_seasonality
[True, False], # weekly_seasonality
[True, False], # daily_seasonality
[None, holiday], # holidays
['additive', 'multiplicative'], # seasonality_mode
[1.1], # seasonality_prior_scale
[1.1], # holidays_prior_scale
[0.1], # changepoint_prior_scale
[100], # mcmc_samples
[0.9], # interval_width
[200] # uncertainty_samples
)
# Values should be copied correctly
for product in products:
m1 = Prophet(*product)
m1.history = m1.setup_dataframe(
df.copy(), initialize_scales=True)
m1.set_auto_seasonalities()
m2 = diagnostics.prophet_copy(m1)
self.assertEqual(m1.growth, m2.growth)
self.assertEqual(m1.n_changepoints, m2.n_changepoints)
self.assertEqual(m1.changepoint_range, m2.changepoint_range)
self.assertEqual(m1.changepoints, m2.changepoints)
self.assertEqual(False, m2.yearly_seasonality)
self.assertEqual(False, m2.weekly_seasonality)
self.assertEqual(False, m2.daily_seasonality)
self.assertEqual(
m1.yearly_seasonality, 'yearly' in m2.seasonalities)
self.assertEqual(
m1.weekly_seasonality, 'weekly' in m2.seasonalities)
self.assertEqual(
m1.daily_seasonality, 'daily' in m2.seasonalities)
if m1.holidays is None:
self.assertEqual(m1.holidays, m2.holidays)
else:
self.assertTrue((m1.holidays == m2.holidays).values.all())
self.assertEqual(m1.seasonality_mode, m2.seasonality_mode)
self.assertEqual(m1.seasonality_prior_scale, m2.seasonality_prior_scale)
self.assertEqual(m1.changepoint_prior_scale, m2.changepoint_prior_scale)
self.assertEqual(m1.holidays_prior_scale, m2.holidays_prior_scale)
self.assertEqual(m1.mcmc_samples, m2.mcmc_samples)
self.assertEqual(m1.interval_width, m2.interval_width)
self.assertEqual(m1.uncertainty_samples, m2.uncertainty_samples)
# Check for cutoff and custom seasonality and extra regressors
changepoints = pd.date_range('2012-06-15', '2012-09-15')
cutoff = pd.Timestamp('2012-07-25')
m1 = Prophet(changepoints=changepoints)
m1.add_seasonality('custom', 10, 5)
m1.add_regressor('binary_feature')
m1.fit(df)
m2 = diagnostics.prophet_copy(m1, cutoff=cutoff)
changepoints = changepoints[changepoints <= cutoff]
self.assertTrue((changepoints == m2.changepoints).all())
self.assertTrue('custom' in m2.seasonalities)
self.assertTrue('binary_feature' in m2.extra_regressors)
