def debug_logger():
log.info("testing: Logger")
log.setLevel("ERROR")
log.parent.setLevel("WARNING")
log.warning("### this WARNING should not show ###")
log.parent.warning("1--- this WARNING should show")
log.error("2--- this ERROR should show")
log.setLevel("DEBUG")
log.parent.setLevel("ERROR")
log.debug("3--- this DEBUG should show")
log.parent.warning("### this WARNING not show ###")
log.error("4--- this ERROR should show")
log.parent.error("5--- this ERROR should show, too")
# test existing test cases
# test_all(log_level="DEBUG")
# test the set_log_level function
log.parent.parent.setLevel("INFO")
m = NeuralProphet(
n_forecasts=3,
n_lags=5,
yearly_seasonality=False,
weekly_seasonality=False,
daily_seasonality=False,
epochs=5,
)
set_log_level("DEBUG")
log.parent.parent.debug("6--- this DEBUG should show")
set_log_level(log_level="WARNING")
log.parent.parent.debug("### this DEBUG should not show ###")
log.parent.parent.info("### this INFO should not show ###")
def predict(
self,
forecast_length: int,
future_regressor=None,
just_point_forecast: bool = False,
):
"""Generates forecast data immediately following dates of index supplied to .fit()
Args:
forecast_length (int): Number of periods of data to forecast ahead
regressor (numpy.Array): additional regressor, not used
just_point_forecast (bool): If True, return a pandas.DataFrame of just point forecasts
Returns:
Either a PredictionObject of forecasts and metadata, or
if just_point_forecast == True, a dataframe of point forecasts
"""
predictStartTime = datetime.datetime.now()
from neuralprophet import NeuralProphet, set_log_level
# defining in function helps with Joblib it seems
def seek_the_oracle(current_series, args, series, forecast_length,
future_regressor):
"""Prophet for for loop or parallel."""
current_series = current_series.rename(columns={series: 'y'})
current_series['ds'] = current_series.index
try:
quant_range = (1 - args['prediction_interval']) / 2
quantiles = [quant_range, 0.5, (1 - quant_range)]
m = NeuralProphet(
quantiles=quantiles,
growth=self.growth,
n_changepoints=self.n_changepoints,
changepoints_range=self.changepoints_range,
trend_reg=self.trend_reg,
trend_reg_threshold=self.trend_reg_threshold,
ar_sparsity=self.ar_sparsity,
yearly_seasonality=self.yearly_seasonality,
weekly_seasonality=self.weekly_seasonality,
daily_seasonality=self.daily_seasonality,
seasonality_mode=self.seasonality_mode,
seasonality_reg=self.seasonality_reg,
n_lags=self.n_lags,
n_forecasts=forecast_length,
num_hidden_layers=self.num_hidden_layers,
d_hidden=self.d_hidden,
learning_rate=self.learning_rate,
loss_func=self.loss_func,
train_speed=self.train_speed,
normalize=self.normalize,
collect_metrics=False,
)
except Exception:
m = NeuralProphet(
growth=self.growth,
n_changepoints=self.n_changepoints,
changepoints_range=self.changepoints_range,
trend_reg=self.trend_reg,
trend_reg_threshold=self.trend_reg_threshold,
ar_sparsity=self.ar_sparsity,
yearly_seasonality=self.yearly_seasonality,
weekly_seasonality=self.weekly_seasonality,
daily_seasonality=self.daily_seasonality,
seasonality_mode=self.seasonality_mode,
seasonality_reg=self.seasonality_reg,
n_lags=self.n_lags,
n_forecasts=forecast_length,
num_hidden_layers=self.num_hidden_layers,
d_hidden=self.d_hidden,
learning_rate=self.learning_rate,
loss_func=self.loss_func,
train_speed=self.train_speed,
normalize=self.normalize,
collect_metrics=False,
)
if args['holiday']:
m.add_country_holidays(country_name=args['holiday_country'])
if args['regression_type'] == 'User':
current_series = pd.concat(
[current_series, args['regressor_train']], axis=1)
for nme in args['regressor_name']:
m.add_future_regressor(nme)
m.fit(current_series,
freq=args['freq'],
progress_print=False,
minimal=True)
if args['regression_type'] == 'User':
if future_regressor.ndim > 1:
if future_regressor.shape[1] > 1:
ft_regr = (future_regressor.mean(
axis=1).to_frame().merge(
future_regressor.std(axis=1).to_frame(),
left_index=True,
right_index=True,
))
else:
ft_regr = future_regressor.copy()
ft_regr.columns = args['regressor_train'].columns
regr = pd.concat([args['regressor_train'], ft_regr])
regr.columns = args['regressor_train'].columns
# regr.index.name = 'ds'
# regr.reset_index(drop=False, inplace=True)
# future = future.merge(regr, on="ds", how='left')
else:
# a = np.append(args['regressor_train'], future_regressor.values)
regr = future_regressor
future = m.make_future_dataframe(current_series,
periods=forecast_length,
regressors_df=regr)
else:
future = m.make_future_dataframe(current_series,
periods=forecast_length)
fcst = m.predict(future, decompose=False)
fcst = fcst.tail(forecast_length) # remove the backcast
# predicting that someday they will change back to fbprophet format
if "yhat2" in fcst.columns:
fcst['yhat1'] = fcst.fillna(0).sum(axis=1, numeric_only=True)
try:
forecast = fcst['yhat1']
except Exception:
forecast = fcst['yhat']
forecast.name = series
# not yet supported, so fill with the NaN column for now if missing
try:
lower_forecast = fcst['yhat_lower']
upper_forecast = fcst['yhat_upper']
except Exception:
lower_forecast = fcst['y']
upper_forecast = fcst['y']
lower_forecast.name = series
upper_forecast.name = series
return (forecast, lower_forecast, upper_forecast)
test_index = self.create_forecast_index(
forecast_length=forecast_length)
if self.verbose < 0:
set_log_level("CRITICAL")
elif self.verbose < 1:
set_log_level("ERROR")
args = {
'freq': self.frequency,
'holiday': self.holiday,
'holiday_country': self.holiday_country,
'regression_type': self.regression_type,
'regressor_name': self.regressor_name,
'regressor_train': self.regressor_train,
'prediction_interval': self.prediction_interval,
}
parallel = True
cols = self.df_train.columns.tolist()
if self.n_jobs in [0, 1] or len(cols) < 4:
parallel = False
else:
try:
from joblib import Parallel, delayed
except Exception:
parallel = False
# joblib multiprocessing to loop through series
if parallel:
verbs = 0 if self.verbose < 1 else self.verbose - 1
df_list = Parallel(n_jobs=self.n_jobs, verbose=(verbs))(
delayed(seek_the_oracle)(
current_series=self.df_train[col].to_frame(),
args=args,
series=col,
forecast_length=forecast_length,
future_regressor=future_regressor,
) for col in cols)
else:
df_list = []
for col in cols:
df_list.append(
seek_the_oracle(
self.df_train[col].to_frame(),
args,
col,
forecast_length=forecast_length,
future_regressor=future_regressor,
))
complete = list(map(list, zip(*df_list)))
forecast = pd.concat(complete[0], axis=1)
forecast.index = test_index
forecast = forecast[self.column_names]
lower_forecast = pd.concat(complete[1], axis=1)
lower_forecast.index = test_index
lower_forecast = lower_forecast[self.column_names]
upper_forecast = pd.concat(complete[2], axis=1)
upper_forecast.index = test_index
upper_forecast = upper_forecast[self.column_names]
if lower_forecast.isnull().to_numpy().any():
upper_forecast, lower_forecast = Point_to_Probability(
self.df_train,
forecast,
method='inferred_normal',
prediction_interval=self.prediction_interval,
)
if just_point_forecast:
return forecast
else:
predict_runtime = datetime.datetime.now() - predictStartTime
prediction = PredictionObject(
model_name=self.name,
forecast_length=forecast_length,
forecast_index=forecast.index,
forecast_columns=forecast.columns,
lower_forecast=lower_forecast,
forecast=forecast,
upper_forecast=upper_forecast,
prediction_interval=self.prediction_interval,
predict_runtime=predict_runtime,
fit_runtime=self.fit_runtime,
model_parameters=self.get_params(),
)
return prediction
import pandas as pd
from neuralprophet import NeuralProphet, set_log_level
import matplotlib.pyplot as plt
set_log_level("ERROR")
df = pd.read_csv("~/DEVELOPMENT/DSDE/NP/RESOURCES/DATA/yosemite_temps.csv",
parse_dates=['ds'])
# print(df.info())
# print(df.head())
m = NeuralProphet(
n_lags=12,
changepoints_range=0.95,
n_changepoints=30,
weekly_seasonality=False,
batch_size=64,
epochs=10,
learning_rate=1.0,
)
metrics = m.fit(df, freq='5min')
future = m.make_future_dataframe(df, n_historic_predictions=True)
forecast = m.predict(future)
fig = m.plot(forecast)
plt.show()
'''
Multi-step forecast
To predict multiple steps into the future, we could 'unroll' our single-step model, by predicting a step ahead, adding the forecasted value to our data, and then forecasting the next step until we reach the horizon we are interested in. However, there is a better way to do this: We can directly forecast multiple steps ahead with NeuralProphet.
We can set n_forecasts to the desired number of steps we would like to forecast (also known as 'forecast horizon'). NeuralProphet will forecast n_forecasts steps into the future, at every single step. Thus, we have n_forecasts overlapping predictions of vaying age at every historic point.