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)