def neural_prophet(data): m = NeuralProphet() m.fit(data, freq='D', epochs=1000) future = m.make_future_dataframe(data, periods=7) forecast = m.predict(future) plot_neural_prophet(forecast, m) return forecast.iloc[:, 2].tolist()
def test_custom_torch_loss(): log.info("TEST PyTorch Custom Loss") class MyLoss(torch.nn.modules.loss._Loss): def forward(self, input, target): alpha = 0.9 y_diff = target - input yhat_diff = input - target loss = (( alpha * torch.max(y_diff, torch.zeros_like(y_diff)) + (1 - alpha) * torch.max(yhat_diff, torch.zeros_like(yhat_diff)) ).sum().mean()) return loss df = pd.read_csv(YOS_FILE, nrows=NROWS) m = NeuralProphet(loss_func=MyLoss, ) with pytest.raises(ValueError): # find_learning_rate only suports normal torch Loss functions metrics = m.fit(df, freq="5min") df = pd.read_csv(YOS_FILE, nrows=NROWS) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, loss_func=MyLoss, learning_rate=1, # bypasses find_learning_rate ) metrics = m.fit(df, freq="5min") future = m.make_future_dataframe(df, periods=12, n_historic_predictions=12) forecast = m.predict(future)
def test_random_seed(self): log.info("TEST random seed") df = pd.read_csv(PEYTON_FILE, nrows=512) set_random_seed(0) m = NeuralProphet(epochs=1) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future) checksum1 = sum(forecast["yhat1"].values) set_random_seed(0) m = NeuralProphet(epochs=1) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future) checksum2 = sum(forecast["yhat1"].values) set_random_seed(1) m = NeuralProphet(epochs=1) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future) checksum3 = sum(forecast["yhat1"].values) log.debug("should be same: {} and {}".format(checksum1, checksum2)) log.debug("should not be same: {} and {}".format(checksum1, checksum3)) assert math.isclose(checksum1, checksum2) assert not math.isclose(checksum1, checksum3)
def neural_prophet(params: Dict[str, Union[bool, float, int]], df: pd.DataFrame, freq: str) -> pd.DataFrame: model = NeuralProphet(**params) model.fit(df, freq=freq) future = model.make_future_dataframe(df, periods=144) forecast = model.predict(future) return forecast
def test_train_eval_test(self): log.info("testing: Train Eval Test") m = NeuralProphet( n_lags=10, n_forecasts=3, ar_sparsity=0.1, epochs=3, batch_size=32, ) df = pd.read_csv(PEYTON_FILE, nrows=95) df = df_utils.check_dataframe(df, check_y=False) df = m._handle_missing_data(df, freq="D", predicting=False) df_train, df_test = m.split_df(df, freq="D", valid_p=0.1, inputs_overbleed=True) metrics = m.fit(df_train, freq="D", validate_each_epoch=True, valid_p=0.1) metrics = m.fit(df_train, freq="D") val_metrics = m.test(df_test) log.debug("Metrics: train/eval: \n {}".format( metrics.to_string(float_format=lambda x: "{:6.3f}".format(x)))) log.debug("Metrics: test: \n {}".format( val_metrics.to_string(float_format=lambda x: "{:6.3f}".format(x))))
def test_callable_loss(): log.info("TEST Callable Loss") def my_loss(output, target): assym_penalty = 1.25 beta = 1 e = target - output me = torch.abs(e) z = torch.where(me < beta, 0.5 * (me**2) / beta, me - 0.5 * beta) z = torch.where(e < 0, z, assym_penalty * z) return z df = pd.read_csv(YOS_FILE, nrows=NROWS) m = NeuralProphet( seasonality_mode="multiplicative", loss_func=my_loss, ) with pytest.raises(ValueError): # find_learning_rate only suports normal torch Loss functions metrics = m.fit(df, freq="5min") df = pd.read_csv(YOS_FILE, nrows=NROWS) m = NeuralProphet( loss_func=my_loss, epochs=EPOCHS, batch_size=BATCH_SIZE, learning_rate=0.1, # bypasses find_learning_rate ) metrics = m.fit(df, freq="5min") future = m.make_future_dataframe(df, periods=12 * 24, n_historic_predictions=12 * 24) forecast = m.predict(future)
def test_train_speed_custom(self): df = pd.read_csv(PEYTON_FILE, nrows=102)[:100] batch_size = 16 epochs = 4 learning_rate = 1.0 check = { "-2": (int(batch_size / 4), int(epochs * 4), learning_rate / 4), "-1": (int(batch_size / 2), int(epochs * 2), learning_rate / 2), "0": (batch_size, epochs, learning_rate), "1": (int(batch_size * 2), max(1, int(epochs / 2)), learning_rate * 2), "2": (int(batch_size * 4), max(1, int(epochs / 4)), learning_rate * 4), } for train_speed in [-1, 0, 2]: m = NeuralProphet( learning_rate=learning_rate, batch_size=batch_size, epochs=epochs, train_speed=train_speed, ) m.fit(df, freq="D") c = m.config_train log.debug( "train_speed: {}, batch: {}, epoch: {}, learning_rate: {}". format(train_speed, c.batch_size, c.epochs, c.learning_rate)) batch, epoch, lr = check["{}".format(train_speed)] assert c.batch_size == batch assert c.epochs == epoch assert math.isclose(c.learning_rate, lr)
def test_check_duplicate_ds(): # Check whether a ValueError is thrown in case there # are duplicate dates in the ds column of dataframe df = pd.read_csv(PEYTON_FILE, nrows=102)[:50] # introduce duplicates in dataframe df = pd.concat([df, df[8:9]]).reset_index() # Check if error thrown on duplicates m = NeuralProphet( n_lags=24, ar_sparsity=0.5, ) with pytest.raises(ValueError): m.fit(df, freq="D")
def predictions(df: DataFrame) -> DataFrame: """ Make predictions about :param df: Dataframe to make the predictions :return: """ m = NeuralProphet() m.fit(df, freq='D') future = m.make_future_dataframe(df, periods=DAYS_OF_PREDICTION) forecast = m.predict(future) forecast['ds'] = pd.to_datetime(forecast['ds']).dt.strftime('%Y-%m-%d') forecast = forecast.set_index('ds') forecast.rename(columns={'yhat1': 'currency'}, inplace=True) forecast = forecast.round(2) return forecast
def test_custom_changepoints(self): log.info("testing: Custom Changepoints") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) dates = df["ds"][range(1, len(df) - 1, int(len(df) / 5.0))] dates_list = [str(d) for d in dates] dates_array = pd.to_datetime(dates_list).values log.debug("dates: {}".format(dates)) log.debug("dates_list: {}".format(dates_list)) log.debug("dates_array: {} {}".format(dates_array.dtype, dates_array)) for cp in [dates_list, dates_array]: m = NeuralProphet( changepoints=cp, yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, ) # print(m.config_trend) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=60, n_historic_predictions=60) forecast = m.predict(df=future) if self.plot: # m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show()
def test_lag_reg_deep(self): log.info("testing: List of Lagged Regressors (deep)") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=1, n_lags=14, num_hidden_layers=2, d_hidden=32, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(15, min_periods=1).mean() df["C"] = df["y"].rolling(30, min_periods=1).mean() cols = [col for col in df.columns if col not in ["ds", "y"]] m = m.add_lagged_regressor(names=cols) m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D", validate_each_epoch=True) future = m.make_future_dataframe(df, n_historic_predictions=365) forecast = m.predict(future) if self.plot: # print(forecast.to_string()) # m.plot_last_forecast(forecast, include_previous_forecasts=10) # m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show()
def test_custom_seasons(self): log.info("testing: Custom Seasonality") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) # m = NeuralProphet(n_lags=60, n_changepoints=10, n_forecasts=30, verbose=True) other_seasons = False m = NeuralProphet( yearly_seasonality=other_seasons, weekly_seasonality=other_seasons, daily_seasonality=other_seasons, seasonality_mode="additive", # seasonality_mode="multiplicative", seasonality_reg=1, epochs=EPOCHS, batch_size=BATCH_SIZE, ) m = m.add_seasonality(name="quarterly", period=90, fourier_order=5) log.debug("seasonalities: {}".format(m.season_config.periods)) metrics_df = m.fit(df, freq="D", validate_each_epoch=True) future = m.make_future_dataframe(df, n_historic_predictions=365, periods=365) forecast = m.predict(df=future) log.debug("season params: {}".format(m.model.season_params.items())) if self.plot: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show()
def test_future_reg(self): log.info("testing: Future Regressors") df = pd.read_csv(PEYTON_FILE) m = NeuralProphet( n_forecasts=1, n_lags=0, epochs=EPOCHS, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(30, min_periods=1).mean() m = m.add_future_regressor(name="A", regularization=0.5) m = m.add_future_regressor(name="B", mode="multiplicative", regularization=0.3) metrics_df = m.fit(df, freq="D") regressors_df = pd.DataFrame(data={ "A": df["A"][:50], "B": df["B"][:50] }) future = m.make_future_dataframe(df=df, regressors_df=regressors_df, n_historic_predictions=10, periods=50) forecast = m.predict(df=future) if self.plot: # print(forecast.to_string()) # m.plot_last_forecast(forecast, include_previous_forecasts=3) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show()
def test_future_reg(self): log.info("testing: Future Regressors") df = pd.read_csv(PEYTON_FILE, nrows=NROWS + 50) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(30, min_periods=1).mean() regressors_df_future = pd.DataFrame(data={ "A": df["A"][-50:], "B": df["B"][-50:] }) df = df[:-50] m = m.add_future_regressor(name="A") m = m.add_future_regressor(name="B", mode="multiplicative") metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df=df, regressors_df=regressors_df_future, n_historic_predictions=10, periods=50) forecast = m.predict(df=future) if self.plot: m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show()
def test_ar_net(self): log.info("testing: AR-Net") df = pd.read_csv(PEYTON_FILE) m = NeuralProphet( n_forecasts=7, n_lags=14, # ar_sparsity=0.01, # num_hidden_layers=0, num_hidden_layers=2, d_hidden=64, # yearly_seasonality=False, # weekly_seasonality=False, # daily_seasonality=False, epochs=EPOCHS, ) m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D", validate_each_epoch=True) future = m.make_future_dataframe(df, n_historic_predictions=len(df) - m.n_lags) forecast = m.predict(df=future) if self.plot: m.plot_last_forecast(forecast, include_previous_forecasts=3) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show()
def test_lag_reg(self): log.info("testing: Lagged Regressors") df = pd.read_csv(PEYTON_FILE) m = NeuralProphet( n_forecasts=3, n_lags=7, ar_sparsity=0.1, # num_hidden_layers=2, # d_hidden=64, # yearly_seasonality=False, # weekly_seasonality=False, # daily_seasonality=False, epochs=EPOCHS, ) if m.n_lags > 0: df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(30, min_periods=1).mean() m = m.add_lagged_regressor(name="A") m = m.add_lagged_regressor(name="B", only_last_value=True) # m.highlight_nth_step_ahead_of_each_forecast(m.n_forecasts) metrics_df = m.fit(df, freq="D", validate_each_epoch=True) future = m.make_future_dataframe(df, n_historic_predictions=365) forecast = m.predict(future) if self.plot: # print(forecast.to_string()) m.plot_last_forecast(forecast, include_previous_forecasts=10) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show()
def nprophet_fit_and_predict_simple( y: [float], k: int, freq: str = None, model_params: dict = None) -> Tuple[List, List, Any, Any]: """ Simpler wrapper for testing - univariate only """ assert isinstance(y[0], float) freq = freq or NPROPHET_META['freq'] used_params = NPROPHET_MODEL used_params.update({'n_forecasts': k}) if model_params: used_params.update(model_params) if len(y) < used_params['n_lags']: x = [wrap(y)[0]] * k x_std = [1.0] * k return x, x_std, None, None else: model = NeuralProphet(**used_params) model.set_log_level(log_level='CRITICAL') df = pd.DataFrame(columns=['y'], data=y) df['ds'] = pd.date_range(start='2021-01-01', periods=len(y), freq=freq) metrics = model.fit(df, freq=freq, epochs=40, use_tqdm=False) future = model.make_future_dataframe(df) forecast = model.predict(future) x = [ forecast['yhat' + str(j + 1)].values[-k + j] for j in range(k) ] x_std = [1.0] * k return x, x_std, forecast, model
def test_seasons(self): log.info("testing: Seasonality") df = pd.read_csv(PEYTON_FILE, nrows=512) # m = NeuralProphet(n_lags=60, n_changepoints=10, n_forecasts=30, verbose=True) m = NeuralProphet( yearly_seasonality=8, weekly_seasonality=4, # daily_seasonality=False, seasonality_mode="additive", # seasonality_mode="multiplicative", seasonality_reg=1, epochs=EPOCHS, ) metrics_df = m.fit(df, freq="D", validate_each_epoch=True) future = m.make_future_dataframe(df, n_historic_predictions=len(df), periods=365) forecast = m.predict(df=future) log.debug("SUM of yearly season params: {}".format( sum(abs(m.model.season_params["yearly"].data.numpy())))) log.debug("SUM of weekly season params: {}".format( sum(abs(m.model.season_params["weekly"].data.numpy())))) log.debug("season params: {}".format(m.model.season_params.items())) if self.plot: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show()
def test_plot(self): log.info("testing: Plotting") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=7, n_lags=14, epochs=EPOCHS, batch_size=BATCH_SIZE, ) metrics_df = m.fit(df, freq="D") m.highlight_nth_step_ahead_of_each_forecast(7) future = m.make_future_dataframe(df, n_historic_predictions=10) forecast = m.predict(future) m.plot(forecast) m.plot_last_forecast(forecast, include_previous_forecasts=10) m.plot_components(forecast) m.plot_parameters() m.highlight_nth_step_ahead_of_each_forecast(None) future = m.make_future_dataframe(df, n_historic_predictions=10) forecast = m.predict(future) m.plot(forecast) m.plot_last_forecast(forecast) m.plot_components(forecast) m.plot_parameters() if self.plot: plt.show()
def test_trend(self): log.info("testing: Trend") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( growth="linear", n_changepoints=10, changepoints_range=0.9, trend_reg=1, trend_reg_threshold=False, yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, ) # print(m.config_trend) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=60, n_historic_predictions=60) forecast = m.predict(df=future) if self.plot: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show()
def test_callable_loss(self): log.info("TEST Callable Loss") def loss(output, target): assym_penalty = 1.25 beta = 1 e = target - output me = torch.abs(e) z = torch.where(me < beta, 0.5 * (me**2) / beta, me - 0.5 * beta) z = torch.where(e < 0, z, assym_penalty * z) return z.mean() df = pd.read_csv(YOS_FILE, nrows=NROWS) m = NeuralProphet( seasonality_mode="multiplicative", loss_func=loss, changepoints_range=0.95, n_changepoints=15, weekly_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, ) metrics = m.fit(df, freq="5min") future = m.make_future_dataframe(df, periods=12 * 24, n_historic_predictions=12 * 24) forecast = m.predict(future)
def test_lag_reg(self): log.info("testing: Lagged Regressors") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( n_forecasts=2, n_lags=3, weekly_seasonality=False, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, ) df["A"] = df["y"].rolling(7, min_periods=1).mean() df["B"] = df["y"].rolling(30, min_periods=1).mean() m = m.add_lagged_regressor(names="A") m = m.add_lagged_regressor(names="B", only_last_value=True) metrics_df = m.fit(df, freq="D", validate_each_epoch=True) future = m.make_future_dataframe(df, n_historic_predictions=10) forecast = m.predict(future) if self.plot: print(forecast.to_string()) m.plot_last_forecast(forecast, include_previous_forecasts=5) m.plot(forecast) m.plot_components(forecast) m.plot_parameters() plt.show()
def test_loss_func(self): log.info("TEST setting torch.nn loss func") df = pd.read_csv(PEYTON_FILE, nrows=512) loss_fn = torch.nn.MSELoss() m = NeuralProphet(epochs=1, loss_func=loss_fn) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future)
def test_events(self): log.info("testing: Events") df = pd.read_csv(PEYTON_FILE)[-NROWS:] playoffs = pd.DataFrame( { "event": "playoff", "ds": pd.to_datetime( [ "2008-01-13", "2009-01-03", "2010-01-16", "2010-01-24", "2010-02-07", "2011-01-08", "2013-01-12", "2014-01-12", "2014-01-19", "2014-02-02", "2015-01-11", "2016-01-17", "2016-01-24", "2016-02-07", ] ), } ) superbowls = pd.DataFrame( { "event": "superbowl", "ds": pd.to_datetime(["2010-02-07", "2014-02-02", "2016-02-07"]), } ) events_df = pd.concat((playoffs, superbowls)) m = NeuralProphet( n_lags=2, n_forecasts=30, daily_seasonality=False, epochs=EPOCHS, batch_size=BATCH_SIZE, ) # set event windows m = m.add_events( ["superbowl", "playoff"], lower_window=-1, upper_window=1, mode="multiplicative", regularization=0.5 ) # add the country specific holidays m = m.add_country_holidays("US", mode="additive", regularization=0.5) history_df = m.create_df_with_events(df, events_df) metrics_df = m.fit(history_df, freq="D") future = m.make_future_dataframe(df=history_df, events_df=events_df, periods=30, n_historic_predictions=90) forecast = m.predict(df=future) log.debug("Event Parameters:: {}".format(m.model.event_params)) if self.plot: m.plot_components(forecast) m.plot(forecast) m.plot_parameters() plt.show()
def test_global_modeling_validation_df(): log.info("Global Modeling + Local Normalization") df = pd.read_csv(PEYTON_FILE, nrows=512) df1_0 = df.iloc[:128, :].copy(deep=True) df2_0 = df.iloc[128:256, :].copy(deep=True) df_dict = {"df1": df1_0, "df2": df2_0} m = NeuralProphet(n_forecasts=2, n_lags=10, epochs=EPOCHS, batch_size=BATCH_SIZE) with pytest.raises(ValueError): m.fit(df_dict, freq="D", validation_df=df2_0) log.info("Error - name of validation df was not provided") m = NeuralProphet(n_forecasts=2, n_lags=10, epochs=EPOCHS, batch_size=BATCH_SIZE) m.fit(df_dict, freq="D", validation_df={"df2": df2_0})
def test_reg_delay(self): df = pd.read_csv(PEYTON_FILE, nrows=102)[:100] m = NeuralProphet(epochs=10) m.fit(df, freq="D") c = m.config_train for w, e, i in [ (0, 0, 1), (0, 3, 0), (0, 5, 0), (0.002739052315863355, 5, 0.1), (0.5, 6, 0.5), (0.9972609476841366, 7, 0.9), (1, 7, 1), (1, 8, 0), ]: weight = c.get_reg_delay_weight(e, i, reg_start_pct=0.5, reg_full_pct=0.8) log.debug("e {}, i {}, expected w {}, got w {}".format(e, i, w, weight)) assert weight == w
def test_seasons(): log.info("testing: Seasonality: additive") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) # m = NeuralProphet(n_lags=60, n_changepoints=10, n_forecasts=30, verbose=True) m = NeuralProphet( yearly_seasonality=8, weekly_seasonality=4, seasonality_mode="additive", seasonality_reg=1, epochs=EPOCHS, batch_size=BATCH_SIZE, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=365, periods=365) forecast = m.predict(df=future) log.debug("SUM of yearly season params: {}".format( sum(abs(m.model.season_params["yearly"].data.numpy())))) log.debug("SUM of weekly season params: {}".format( sum(abs(m.model.season_params["weekly"].data.numpy())))) log.debug("season params: {}".format(m.model.season_params.items())) if PLOT: m.plot(forecast) # m.plot_components(forecast) m.plot_parameters() plt.show() log.info("testing: Seasonality: multiplicative") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) # m = NeuralProphet(n_lags=60, n_changepoints=10, n_forecasts=30, verbose=True) m = NeuralProphet( yearly_seasonality=8, weekly_seasonality=4, seasonality_mode="multiplicative", epochs=EPOCHS, batch_size=BATCH_SIZE, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, n_historic_predictions=365, periods=365) forecast = m.predict(df=future)
def test_loss_func_torch(): log.info("TEST setting torch.nn loss func") df = pd.read_csv(PEYTON_FILE, nrows=512) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, loss_func=torch.nn.MSELoss, ) metrics_df = m.fit(df, freq="D") future = m.make_future_dataframe(df, periods=10, n_historic_predictions=10) forecast = m.predict(future)
def test_metrics(): log.info("testing: Plotting") df = pd.read_csv(PEYTON_FILE, nrows=NROWS) m = NeuralProphet( epochs=EPOCHS, batch_size=BATCH_SIZE, collect_metrics=["MAE", "MSE", "RMSE"], ) metrics_df = m.fit(df, freq="D") assert metrics_df is not None forecast = m.predict(df)
def test_global_modeling_global_normalization(): ### GLOBAL MODELLING - NO EXOGENOUS VARIABLES - GLOBAL NORMALIZATION log.info("Global Modeling + Global Normalization") df = pd.read_csv(PEYTON_FILE, nrows=512) df1_0 = df.iloc[:128, :].copy(deep=True) df2_0 = df.iloc[128:256, :].copy(deep=True) df3_0 = df.iloc[256:384, :].copy(deep=True) m = NeuralProphet(n_forecasts=2, n_lags=10, epochs=EPOCHS, batch_size=BATCH_SIZE, global_normalization=True) train_dict = {"df1": df1_0, "df2": df2_0} test_dict = {"df3": df3_0} m.fit(train_dict) future = m.make_future_dataframe(test_dict) forecast = m.predict(future) metrics = m.test(test_dict) forecast_trend = m.predict_trend(test_dict) forecast_seasonal_componets = m.predict_seasonal_components(test_dict)