pynnlf 0.2.2__py3-none-any.whl

pynnlf/scaffold/models/m16_prophet.py

@@ -0,0 +1,216 @@
+# IMPORT IMPORTANT LIBRARY
+import pandas as pd
+from prophet import Prophet
+import numpy as np
+from pynnlf.model_utils import remove_jump_df, separate_lag_and_exogenous_features
+
+def train_model_m16_prophet(hyperparameter, train_df_X, train_df_y, forecast_horizon):
+    ''' Train a prophet model for point forecasting. 
+        
+    Args:
+        hyperparameter (df) : hyperparameter value of the model consisting of number of features
+        train_df_X (df) : features matrix for training
+        train_df_y (df) : target matrix for training
+        forecast_horizon (int) : forecast horizon for the model
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    seed = hyperparameter["seed"]
+    seasonality_prior_scale = hyperparameter["seasonality_prior_scale"]
+    seasonality_mode = hyperparameter["seasonality_mode"]
+    weekly_seasonality = hyperparameter["weekly_seasonality"]
+    daily_seasonality = hyperparameter["daily_seasonality"]
+    growth = hyperparameter["growth"]
+    
+    
+    # UPDATE train_df to exclude all rows after a sudden jump in the timestep
+    train_df_y_updated = remove_jump_df(train_df_y)
+    train_df_X_updated = remove_jump_df(train_df_X)
+
+    # Calculate the frequency of the timesteps using the first and second index values
+    timestep_frequency = train_df_y_updated.index[1] - train_df_y_updated.index[0]
+    inferred_frequency = pd.infer_freq(train_df_y_updated.index)
+    train_df_y_updated = train_df_y_updated.asfreq(inferred_frequency) 
+
+    # INTRODUCE GAP BETWEEN TRAIN AND TEST SET TO AVOID DATA LEAKAGE
+    n_timestep_forecast_horizon = int(forecast_horizon / (timestep_frequency.total_seconds() / 60))
+    if n_timestep_forecast_horizon == 1:
+        pass
+    else:
+        train_df_y_updated = train_df_y_updated[:-(n_timestep_forecast_horizon - 1)]
+        train_df_X_updated = train_df_X_updated[:-(n_timestep_forecast_horizon - 1)]
+
+    # Assuming train_df_y_updated is your dataframe and 'y' is the column with the training series
+    y = train_df_y_updated.copy()
+    X_lags, X_exog = separate_lag_and_exogenous_features(train_df_X_updated)
+
+    #Initialize the Prophet model with hyperparameters
+    prophet_model = Prophet(
+        seasonality_prior_scale=seasonality_prior_scale,  # Example hyperparameter for seasonality strength
+        seasonality_mode=seasonality_mode,  # Use multiplicative seasonality
+        weekly_seasonality=weekly_seasonality,  # Enable weekly seasonality
+        daily_seasonality=daily_seasonality,  # Enable daily seasonality
+        growth=growth  # Choose between 'linear' or 'logistic' growth
+        # random_state =  seed,  # cannot set seed in prophet
+    )
+    for col in X_exog.columns:
+        prophet_model.add_regressor(col)
+
+    # Add exogenous features to the y DataFrame
+    y = y.merge(X_exog, on='datetime')
+    y.reset_index(inplace=True)
+    y.rename(columns={'datetime': 'ds'}, inplace=True)
+    
+    # Train model
+    prophet_model.fit(y)
+  
+    # PACK MODEL
+    model = {"prophet": prophet_model, "y": y, "hyperparameter": hyperparameter}
+  
+
+    return model
+
+def produce_forecast_m16_prophet(model, train_df_X, test_df_X, train_df_y, forecast_horizon):
+    """Create forecast at the train and test set using the trained model
+
+    Args:
+        model (dictionary): all parameters of the trained model
+        train_df_X (df): predictors of train set
+        test_df_X (df): predictors of test set
+        train_df_y (df): target of train set
+        forecast_horizon (int): forecast horizon for the model
+
+    Returns:
+        train_df_y_hat (df) : forecast result at train set
+        test_df_y_hat (df) : forecast result at test set
+        
+    """
+    
+    # UNPACK MODEL
+    prophet_model = model['prophet']
+    y = model['y']
+    hyperparameter = model['hyperparameter']
+    
+    #UNPACK HYPERPARAMETER
+    seasonality_prior_scale = hyperparameter["seasonality_prior_scale"]
+    seasonality_mode = hyperparameter["seasonality_mode"]
+    weekly_seasonality = hyperparameter["weekly_seasonality"]
+    daily_seasonality = hyperparameter["daily_seasonality"]
+    growth = hyperparameter["growth"]
+    
+    # Set up X_exog which is used for prediction
+    timestep_frequency = test_df_X.index[1] - test_df_X.index[0]
+    n_timestep_forecast_horizon = int(forecast_horizon / (timestep_frequency.total_seconds() / 60))
+            
+    train_df_X_updated = remove_jump_df(train_df_X)
+    test_df_X_updated = remove_jump_df(test_df_X)
+
+    X_lags, X_exog = separate_lag_and_exogenous_features(train_df_X_updated)
+
+    X_exog.reset_index(inplace=True)
+    X_exog.rename(columns={'datetime': 'ds'}, inplace=True)
+
+    # Forecast train set
+    train_df_y_hat = prophet_model.predict(X_exog)
+
+    train_df_y_hat = train_df_y_hat[['ds', 'yhat']]
+
+    train_df_y_hat.set_index('ds', inplace=True)
+    train_df_y_hat.index.name = 'datetime'
+    
+    # Set up function to warm start the model for updating the fit
+    def warm_start_params(m):
+        """
+        Retrieve parameters from a trained model in the format used to initialize a new Stan model.
+        Note that the new Stan model must have these same settings:
+            n_changepoints, seasonality features, mcmc sampling
+        for the retrieved parameters to be valid for the new model.
+
+        Parameters
+        ----------
+        m: A trained model of the Prophet class.
+
+        Returns
+        -------
+        A Dictionary containing retrieved parameters of m.
+        """
+        res = {}
+        for pname in ['k', 'm', 'sigma_obs']:
+            if m.mcmc_samples == 0:
+                res[pname] = m.params[pname][0][0]
+            else:
+                res[pname] = np.mean(m.params[pname])
+        for pname in ['delta', 'beta']:
+            if m.mcmc_samples == 0:
+                res[pname] = m.params[pname][0]
+            else:
+                res[pname] = np.mean(m.params[pname], axis=0)
+        return res
+
+    # PRODUCE FORECASTFOR TEST SET
+    
+    # REFIT THE MODEL AND PRODUCE NEW FORECAST FOR TEST SET
+    # The model is refitted for 100 times only so there will be only 100 forecast results. 
+    
+    test_df_y_hat = pd.DataFrame(index = test_df_X.index)
+    test_df_y_hat['y_hat'] = np.nan
+
+
+    # in the case of CV 10, which is when test df < train df
+    # don't compute the test forecast
+    if (test_df_X.index[-1] < train_df_X.index[0]):
+    # this is the case when we use CV10, where the test set is before the train set
+        print("Test set is before train set / CV 10, no test forecast can be made")
+        return train_df_y_hat, test_df_y_hat
+    
+    _, X_test = separate_lag_and_exogenous_features(test_df_X)
+    X_test.reset_index(inplace=True)
+    X_test.rename(columns={'datetime': 'ds'}, inplace=True)
+
+    n_update = 100
+    n_timesteps_per_update = int(len(test_df_y_hat) / (n_update + 1))
+    
+    # TRANSFORM test_df_X to a series with only the last lag
+    horizon_timedelta = pd.Timedelta(minutes=forecast_horizon)
+    last_observation = f'y_lag_{horizon_timedelta}m'
+    test_df_y_last = test_df_X[last_observation]
+
+    new_y = pd.DataFrame(test_df_y_last)
+    new_y.rename(columns={new_y.columns[0]: 'y'}, inplace=True)
+    new_y.insert(0, 'ds', new_y.index - pd.Timedelta(minutes=forecast_horizon))
+    new_y.reset_index(drop = True, inplace=True)
+
+    new_y = new_y.drop(0, axis=0).reset_index(drop=True)
+    X_exog_complete = pd.concat([X_exog, X_test], axis=0)
+    X_exog_complete = X_exog_complete.drop(0, axis=0).reset_index(drop=True)
+    new_y = pd.merge(new_y, X_exog_complete, on='ds', how='left')
+    
+    for i in range(n_update):
+    # for i in range(2): #for test only
+        print('Processing i = ', i + 1, ' out of ', n_update),
+        if i == 0:
+            X_test_curr = X_test.iloc[:1,:]
+            test_df_y_hat.iloc[i, 0] = prophet_model.predict(X_test_curr)['yhat'].values[0]
+        else:
+            new_rows = new_y.iloc[(i-1)*n_timesteps_per_update : i*n_timesteps_per_update, :]
+            y = pd.concat([y, new_rows], ignore_index=True)
+
+            current_params = warm_start_params(prophet_model)
+
+            prophet_model = Prophet(
+                seasonality_prior_scale=seasonality_prior_scale,  # Example hyperparameter for seasonality strength
+                seasonality_mode=seasonality_mode,  # Use multiplicative seasonality
+                weekly_seasonality=weekly_seasonality,  # Enable weekly seasonality
+                daily_seasonality=daily_seasonality,  # Enable daily seasonality
+                growth=growth,  # Choose between 'linear' or 'logistic' growth
+            )
+
+            prophet_model = prophet_model.fit(y, init=current_params)  # Adding the last day, warm-starting from the prev model
+            X_test_curr = X_test.iloc[i*n_timesteps_per_update : (1+i*n_timesteps_per_update),:]
+            test_df_y_hat.iloc[i*n_timesteps_per_update, 0] = prophet_model.predict(X_test_curr)['yhat'].values[0]
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m17_xgb.py

@@ -0,0 +1,66 @@
+# IMPORT IMPORTANT LIBRARY
+import numpy as np
+import pandas as pd
+from xgboost import XGBRegressor
+
+def train_model_m17_xgb(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a xgb model for point forecasting. 
+        
+    Args:
+        hyperparameter (df) : hyperparameter value of the model consisting of number of features
+        train_df_X (df) : features matrix for training
+        train_df_y (df) : target matrix for training
+
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    xgb_seed = int(hyperparameter["xgb_seed"])
+    n_estimators=hyperparameter["n_estimators"]
+    learning_rate=hyperparameter["learning_rate"]
+    max_depth=hyperparameter["max_depth"]
+    subsample=hyperparameter["subsample"]
+    colsample_bytree=hyperparameter["colsample_bytree"]
+    
+    #INITIALIZE AND TRAIN MODEL
+    xgb = XGBRegressor(
+        n_estimators=int(n_estimators),
+        learning_rate=float(learning_rate),
+        max_depth=int(max_depth),
+        subsample=float(subsample),
+        colsample_bytree=float(colsample_bytree),
+        random_state=xgb_seed,
+    )
+    xgb.fit(train_df_X, train_df_y)   
+  
+    # PACK MODEL
+    model = {"xgb": xgb}
+  
+
+    return model
+
+def produce_forecast_m17_xgb(model, train_df_X, test_df_X):
+    """Create forecast at the train and test set using the trained model
+
+    Args:
+        model (dictionary): all parameters of the trained model
+        train_df_X (df): predictors of train set
+        test_df_X (df): predictors of test set
+
+    Returns:
+        train_df_y_hat (df) : forecast result at train set
+        test_df_y_hat (df) : forecast result at test set
+        
+    """
+    
+    # UNPACK MODEL
+    xgb = model["xgb"]
+    
+    # PRODUCE FORECAST
+    train_df_y_hat = xgb.predict(train_df_X)
+    test_df_y_hat = xgb.predict(test_df_X)
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m18_nbeats.py

@@ -0,0 +1,107 @@
+from pyexpat import model
+
+
+def train_model_m18_nbeats(hyperparameter, train_df_X, train_df_y):
+    """
+    Train and test an NBeats model for point forecasting.
+    Uses NBeats architecture for predicting time series with lag+exogenous features.
+    
+    Args:
+        hyperparameter (dict) : model hyperparameters
+        train_df_X (DataFrame) : predictors for training
+        train_df_y (DataFrame) : target for training
+    
+    Returns:
+        model : trained PyTorch NBeats model
+    """
+    # ---- Unpack hyperparameters ----
+    input_size = train_df_X.shape[1]
+    output_size = int(hyperparameter['output_size'])
+    hidden_size = int(hyperparameter['hidden_size'])
+    num_blocks = int(hyperparameter['num_blocks'])
+    num_layers = int(hyperparameter['num_layers'])
+    lr = hyperparameter['lr']
+    epochs = int(hyperparameter['epochs'])
+    seed = int(hyperparameter['seed'])
+
+    # ---- Set seeds for reproducibility ----
+    import torch, numpy as np, random
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+
+    # ---- Define NBeats model inside the function ----
+    import torch.nn as nn
+    class NBeatsModel(nn.Module):
+        def __init__(self, input_size, output_size, hidden_size, num_blocks, num_layers):
+            super(NBeatsModel, self).__init__()
+            blocks = []
+            for _ in range(num_blocks):
+                block = []
+                for l in range(num_layers):
+                    block.append(nn.Linear(input_size if l==0 else hidden_size, hidden_size))
+                    block.append(nn.ReLU())
+                block.append(nn.Linear(hidden_size, output_size))
+                blocks.append(nn.Sequential(*block))
+            self.blocks = nn.ModuleList(blocks)
+
+        def forward(self, x):
+            out = 0
+            for block in self.blocks:
+                out += block(x)
+            return out
+
+    model = NBeatsModel(input_size, output_size, hidden_size, num_blocks, num_layers)
+
+    # ---- Training setup ----
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    criterion = nn.MSELoss()
+    X_tensor = torch.tensor(train_df_X.values, dtype=torch.float32)
+    y_tensor = torch.tensor(train_df_y.values, dtype=torch.float32)
+
+    # ---- Training loop ----
+    model.train()
+    for epoch in range(epochs):
+        optimizer.zero_grad()
+        output = model(X_tensor)
+        loss = criterion(output, y_tensor)
+        loss.backward()
+        optimizer.step()
+    
+    return model
+
+def produce_forecast_m18_nbeats(model, train_df_X, test_df_X):
+    """
+    Create forecast at the train and test set using the trained NBeats model.
+    
+    Args:
+        model : trained NBeats PyTorch model
+        train_df_X (DataFrame) : predictors of train set
+        test_df_X (DataFrame) : predictors of test set
+
+    Returns:
+        train_df_y_hat (DataFrame) : forecast result at train set
+        test_df_y_hat (DataFrame) : forecast result at test set
+    """
+    import torch
+    model.eval()
+    
+    with torch.no_grad():
+        X_train_tensor = torch.tensor(train_df_X.values, dtype=torch.float32)
+        X_test_tensor = torch.tensor(test_df_X.values, dtype=torch.float32)
+        
+        y_train_hat = model(X_train_tensor).detach().cpu().numpy()
+        y_test_hat  = model(X_test_tensor).detach().cpu().numpy()
+    
+    import pandas as pd
+    train_df_y_hat = pd.DataFrame(y_train_hat, index=train_df_X.index, columns=['y_hat'])
+    test_df_y_hat = pd.DataFrame(y_test_hat, index=test_df_X.index, columns=['y_hat'])
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m1_naive.py

@@ -0,0 +1,49 @@
+def train_model_m1_naive(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a naive model for point forecasting. 
+        
+    Args:
+        hyperparameter (df) : hyperparameter value of the model consisting of number of features
+        train_df_X (df) : features matrix for training
+        train_df_y (df) : target matrix for training
+
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    #no hyperparameter for naive model
+    
+    #TRAIN MODEL
+    #no training is required for naive model
+  
+    # PACK MODEL
+    model = {}
+  
+
+    return model
+
+def produce_forecast_m1_naive(model, train_df_X, test_df_X, forecast_horizon):
+    """Create forecast at the train and test set using the trained model
+
+    Args:
+        model (dictionary): all parameters of the trained model
+        train_df_X (df): predictors of train set
+        test_df_X (df): predictors of test set
+
+    Returns:
+        train_df_y_hat (df) : forecast result at train set
+        test_df_y_hat (df) : forecast result at test set
+        
+    """
+    
+    import pandas as pd
+    
+    # PRODUCE FORECAST
+    horizon_timedelta = pd.Timedelta(minutes=forecast_horizon)
+    last_observation = f'y_lag_{horizon_timedelta}m'
+    train_df_y_hat = train_df_X[last_observation]
+    test_df_y_hat = test_df_X[last_observation]
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m2_snaive.py

@@ -0,0 +1,49 @@
+def train_model_m2_snaive(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a seasonal model for point forecasting. 
+        
+    Args:
+        hyperparameter (df) : hyperparameter value of the model consisting of number of features
+        train_df_X (df) : features matrix for training
+        train_df_y (df) : target matrix for training
+
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    days = hyperparameter['days']
+    col_name = f'y_lag_{days} days 00:00:00m'
+    
+    #TRAIN MODEL
+    #no training is required for seasonal naive model
+  
+    # PACK MODEL
+    model = {"col_name": col_name }
+  
+
+    return model
+
+def produce_forecast_m2_snaive(model, train_df_X, test_df_X):
+    """Create forecast at the train and test set using the trained model
+
+    Args:
+        model (dictionary): all parameters of the trained model
+        train_df_X (df): predictors of train set
+        test_df_X (df): predictors of test set
+
+    Returns:
+        train_df_y_hat (df) : forecast result at train set
+        test_df_y_hat (df) : forecast result at test set
+        
+    """
+    
+    # UNPACK MODEL
+    col_name = model['col_name']  #this depends on the lag day
+      
+    # PRODUCE FORECAST
+    train_df_y_hat = train_df_X[col_name]
+    test_df_y_hat = test_df_X[col_name]
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m3_ets.py

@@ -0,0 +1,133 @@
+# IMPORT IMPORTANT LIBRARY
+import pandas as pd
+from statsmodels.tsa.statespace.exponential_smoothing import ExponentialSmoothing
+from pynnlf.model_utils import remove_jump_df
+import numpy as np
+import datetime as dt
+
+def train_model_m3_ets(hyperparameter, train_df_X, train_df_y, forecast_horizon):
+    ''' Train and test a linear model for point forecasting. 
+    https://www.statsmodels.org/dev/generated/statsmodels.tsa.statespace.exponential_smoothing.ExponentialSmoothing.html
+        
+    Args:
+        hyperparameter (df) : hyperparameter value of the model consisting of number of features
+        train_df_X (df) : features matrix for training
+        train_df_y (df) : target matrix for training
+        forecast_horizon (int) : forecast horizon in mins
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    trend = hyperparameter['trend']
+    damped_trend = hyperparameter['damped_trend']
+    seasonal_periods_days = hyperparameter['seasonal_periods_days']
+
+    # UPDATE train_df_y to exclude all rows after a sudden jump in the timestep
+    train_df_y_updated = remove_jump_df(train_df_y)
+        
+    # TRAIN MODEL
+    # Calculate the frequency of the timesteps using the first and second index values
+    timestep_frequency = train_df_y_updated.index[1] - train_df_y_updated.index[0]
+    inferred_frequency = pd.infer_freq(train_df_y_updated.index)
+    train_df_y_updated = train_df_y_updated.asfreq(inferred_frequency) 
+
+    # INTRODUCE GAP BETWEEN TRAIN AND TEST SET TO AVOID DATA LEAKAGE
+    n_timestep_forecast_horizon = int(forecast_horizon / (timestep_frequency.total_seconds() / 60))
+    if n_timestep_forecast_horizon == 1:
+        pass
+    else:
+        train_df_y_updated = train_df_y_updated[:-(n_timestep_forecast_horizon - 1)]
+    
+    # Assuming train_df_y_updated is your dataframe and 'y' is the column with the training series
+    y = train_df_y_updated['y']
+
+   # Build and fit the state-space Exponential Smoothing model
+    model_fitted = ExponentialSmoothing(
+        y,
+        trend=trend,
+        seasonal=None, #can be updated later
+        damped_trend=damped_trend
+    ).fit()
+
+
+    # Print the model summary
+    # print(model_fitted.summary())
+  
+    # PACK MODEL
+    model = {"model_fitted": model_fitted}
+  
+
+    return model
+
+def produce_forecast_m3_ets(model, train_df_X, test_df_X, forecast_horizon):
+    """Create forecast at the train and test set using the trained model
+
+    Args:
+        model (dictionary): all parameters of the trained model
+        train_df_X (df): predictors of train set
+        test_df_X (df): predictors of test set
+        forecast_horizon (int): forecast horizon in mins
+
+    Returns:
+        train_df_y_hat (df) : forecast result at train set
+        test_df_y_hat (df) : forecast result at test set
+        
+    """
+    
+    timestep_frequency = test_df_X.index[1] - test_df_X.index[0]
+    n_timestep_forecast_horizon = int(forecast_horizon / (timestep_frequency.total_seconds() / 60))
+    
+            
+    train_df_X_updated = remove_jump_df(train_df_X)
+    test_df_X_updated = remove_jump_df(test_df_X)
+    
+    # UNPACK MODEL
+    model_fitted = model['model_fitted']
+    
+    # PRODUCE FORECAST FOR TRAIN SET
+    train_df_y_hat = pd.DataFrame(model_fitted.fittedvalues)
+    train_df_y_hat.columns = ['y']
+
+    # train_df_y_hat_2 = pd.DataFrame(model_fitted.forecast(n_timestep_forecast_horizon-1))
+    # train_df_y_hat_2.columns = ['y']
+    # train_df_y_hat = pd.concat([train_df_y_hat, train_df_y_hat_2])
+
+    train_df_y_hat.index.name = 'datetime'
+    
+    # TRANSFORM test_df_X to a series with only the last lag
+    horizon_timedelta = pd.Timedelta(minutes=forecast_horizon)
+    last_observation = f'y_lag_{horizon_timedelta}m'
+    test_df_y_last = test_df_X[last_observation]
+    
+      
+    # REFIT THE MODEL AND PRODUCE NEW FORECAST FOR TEST SET
+    # THIS CODE RESULTS IN 2 MINS
+    test_df_y_hat = pd.DataFrame(index = test_df_X.index)
+    test_df_y_hat['y_hat'] = np.nan
+    
+    
+    # in the case of CV 10, which is when test df < train df
+    # don't compute the test forecast
+    if (test_df_X.index[-1] < train_df_X.index[0]):
+    # this is the case when we use CV10, where the test set is before the train set
+        print("Test set is before train set / CV 10, no test forecast can be made")
+        return train_df_y_hat, test_df_y_hat
+
+    for i in range(len(test_df_y_last)):
+    # for i in range(2): #for test only
+        print('Processing i = ', i + 1, ' out of ', len(test_df_y_last)),
+        if i == 0:
+            test_df_y_hat.iloc[i, 0] = model_fitted.forecast(steps=n_timestep_forecast_horizon).iloc[-1]
+        else:
+            new_row = pd.DataFrame([test_df_y_last.values[i]], columns=['y'], index=[test_df_y_last.index[i] - dt.timedelta(minutes=forecast_horizon)])
+            new_row = new_row.asfreq(test_df_X_updated.index.freq)
+
+            model_fitted = model_fitted.append(new_row)
+            test_df_y_hat.iloc[i, 0] = model_fitted.forecast(steps=n_timestep_forecast_horizon).iloc[-1] # to update based on the forecast horizon
+
+    # test_df_y_hat = m06_lr.predict(test_df_X)
+    
+    return train_df_y_hat, test_df_y_hat
+