pynnlf 0.2.2__py3-none-any.whl

pynnlf/scaffold/models/m4_arima.py

@@ -0,0 +1,123 @@
+# IMPORT IMPORTANT LIBRARY
+from statsmodels.tsa.arima.model import ARIMA
+from pynnlf.model_utils import remove_jump_df
+import pandas as pd
+import numpy as np
+import datetime as dt
+
+def train_model_m4_arima(hyperparameter, train_df_X, train_df_y, forecast_horizon):
+    ''' Train and test a linear 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 in mins
+
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    p = hyperparameter['p']
+    d = hyperparameter['d']
+    q = hyperparameter['q']
+
+    
+    # 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 ARIMA model
+    model_fitted = ARIMA(y, order=(p, d, q), freq=inferred_frequency).fit()
+    
+    # PACK MODEL
+    model = {"model_fitted": model_fitted}
+  
+
+    return model
+
+def produce_forecast_m4_arima(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
+

pynnlf/scaffold/models/m5_sarima.py

@@ -0,0 +1,128 @@
+# IMPORT IMPORTANT LIBRARY
+from statsmodels.tsa.statespace.sarimax import SARIMAX
+from pynnlf.model_utils import remove_jump_df
+import pandas as pd
+import numpy as np
+import datetime as dt
+
+def train_model_m5_sarima(hyperparameter, train_df_X, train_df_y, forecast_horizon):
+    ''' Train and test a linear 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 in mins
+
+    
+    Returns:
+        model (model) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    p = hyperparameter['p']
+    d = hyperparameter['d']
+    q = hyperparameter['q']
+    P = hyperparameter['P']
+    D = hyperparameter['D']
+    Q = hyperparameter['Q']
+    seasonal_period_days = hyperparameter['seasonal_period_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]
+    s = int(seasonal_period_days * 24 * 60 / (timestep_frequency.seconds / 60))
+    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 ARIMA model
+    model_fitted = SARIMAX(y, order=(p, d, q), seasonal_order = (P, D, Q, s), freq=inferred_frequency).fit()
+    
+    # PACK MODEL
+    model = {"model_fitted": model_fitted}
+  
+
+    return model
+
+def produce_forecast_m5_sarima(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
+

pynnlf/scaffold/models/m6_lr.py

@@ -0,0 +1,76 @@
+import sklearn
+from sklearn.feature_selection import SelectKBest, chi2, f_regression
+from sklearn.linear_model import LinearRegression
+
+def train_model_m6_lr(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a linear 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 (dictionary) : trained model with all features
+    '''
+    
+    #UNPACK HYPERPARAMETER
+    num_feature = int(hyperparameter['num_features'])
+    
+    # FEATURE SELECTOR
+    def select_features(train_df_X, train_df_y, num_feature):
+        ''' Make model to select K best feature. 
+            
+        Args:
+            train_df_X (df) : features matrix for training
+            train_df_y (df) : target matrix for training
+        
+        Returns:
+            fs_lr (model) : feature selector
+        '''
+        
+        train_df_y = train_df_y.values.ravel()
+        fs_lr = SelectKBest(f_regression, k = num_feature)
+        fs_lr.fit(train_df_X, train_df_y)
+        
+        return fs_lr
+
+    fs_lr = select_features(train_df_X, train_df_y, num_feature)
+    
+    #TRAIN MODEL
+    train_df_X = fs_lr.transform(train_df_X)
+    m06_lr = LinearRegression()
+    m06_lr.fit(train_df_X, train_df_y)
+  
+    # PACK MODEL
+    model = {"feature_selector": fs_lr, "regression_model": m06_lr}    
+
+    return model
+
+def produce_forecast_m6_lr(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
+        
+    """
+    fs_lr = model['feature_selector']
+    m06_lr = model['regression_model']
+    
+    # SELECT K BEST FEATURES
+    train_df_X = fs_lr.transform(train_df_X)
+    test_df_X = fs_lr.transform(test_df_X)
+    
+    # PRODUCE FORECAST
+    train_df_y_hat = m06_lr.predict(train_df_X)
+    test_df_y_hat = m06_lr.predict(test_df_X)
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m7_ann.py

@@ -0,0 +1,148 @@
+# IMPORT IMPORTANT LIBRARY
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import pandas as pd
+import random
+import os
+
+def train_model_m7_ann(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a linear 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
+
+    # Set random seed for reproducibility
+    def set_seed(seed):
+        random.seed(seed)
+        os.environ["PYTHONHASHSEED"] = str(seed)
+        np.random.seed(seed)
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        torch.backends.cudnn.deterministic = True
+        
+    seed = int(hyperparameter['seed'])
+
+    hidden_size = hyperparameter['hidden_size']
+    activation_function = hyperparameter['activation_function']
+    learning_rate = hyperparameter['learning_rate']
+    # learning_rate = 0.001
+    solver = hyperparameter['solver']
+    epochs = hyperparameter['epochs']
+    
+    # Use proper format for X and y
+    X = torch.tensor(train_df_X.values, dtype=torch.float32)
+    y = torch.tensor(train_df_y.values, dtype=torch.float32).view(-1, 1) 
+    
+    # Define the ANN model
+    class ANNModel(nn.Module):
+        def __init__(self, input_size, hidden_size, output_size):
+            super(ANNModel, self).__init__()
+            self.fc1 = nn.Linear(input_size, hidden_size)
+            self.fc2 = nn.Linear(hidden_size, output_size)
+            self.relu = nn.ReLU()  # Activation function
+
+        def forward(self, x):
+            x = self.fc1(x)
+            if activation_function == 'relu':
+                x = self.relu(x)
+            elif activation_function == 'sigmoid':
+                x = torch.sigmoid(x)
+            else:
+                x = torch.tanh(x)
+            x = self.fc2(x)
+            return x
+        
+    # Model initialization
+    input_size = X.shape[1]
+    output_size = y.shape[1]
+    
+    set_seed(seed)
+    
+    model_ann = ANNModel(input_size, hidden_size, output_size)
+    if solver == 'adam':
+        optimizer = optim.Adam(model_ann.parameters(), lr=learning_rate)
+    elif solver == 'sgd':
+        optimizer = optim.SGD(model_ann.parameters(), lr=learning_rate)
+    else:
+        raise ValueError('Solver not found')
+    
+    # Loss function
+    criterion = nn.MSELoss()  # Mean Squared Error loss for regression
+    
+    #TRAIN MODEL
+    # Training loop
+    for epoch in range(epochs):
+        model_ann.train()
+        
+        # Forward pass
+        output = model_ann(X)
+        loss = criterion(output, y)
+        
+        # Backward pass
+        optimizer.zero_grad()
+        loss.backward()
+        
+        # Update weights
+        optimizer.step()
+        
+        if epoch % 10 == 0:
+            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
+  
+    # PACK MODEL
+    model = {"model_ann": model_ann}
+  
+
+    return model
+
+def produce_forecast_m7_ann(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
+    model_ann = model["model_ann"]
+
+    # PREPARE FORMAT
+    train_df_X_tensor = torch.tensor(train_df_X.values, dtype=torch.float32)
+    test_df_X_tensor = torch.tensor(test_df_X.values, dtype=torch.float32)
+
+    # PRODUCE FORECAST
+    # Switch model to evaluation mode for inference
+    model_ann.eval()
+
+    # TRAIN SET FORECAST
+    with torch.no_grad():  # Disable gradient calculation to save memory
+        train_df_y_hat_tensor = model_ann(train_df_X_tensor)
+
+    # TEST SET FORECAST
+    with torch.no_grad():  # Disable gradient calculation to save memory
+        test_df_y_hat_tensor = model_ann(test_df_X_tensor)
+        
+    # Create DataFrames of result
+    train_df_y_hat = pd.DataFrame(train_df_y_hat_tensor, index=train_df_X.index, columns=['y_hat'])
+    test_df_y_hat = pd.DataFrame(test_df_y_hat_tensor, index=test_df_X.index, columns=['y_hat'])
+    
+    return train_df_y_hat, test_df_y_hat
+
+
+# # MESSY

pynnlf/scaffold/models/m8_dnn.py

@@ -0,0 +1,141 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import numpy as np
+import pandas as pd
+
+def train_model_m8_dnn(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a linear model for point forecasting. 
+    
+    Args:
+        hyperparameter (dict) : hyperparameter value of the model consisting of number of features
+        train_df_X (DataFrame) : features matrix for training
+        train_df_y (DataFrame) : target matrix for training
+    
+    Returns:
+        model (dict) : trained model with all features
+    '''
+    
+    # UNPACK HYPERPARAMETER
+    seed = hyperparameter['seed']
+    torch.manual_seed(seed)  # Set seed for PyTorch
+
+    n_hidden = hyperparameter['n_hidden']
+    hidden_size = hyperparameter['hidden_size']
+    activation_function = hyperparameter['activation_function']
+    learning_rate = hyperparameter['learning_rate']
+    solver = hyperparameter['solver']
+    epochs = hyperparameter['epochs']
+    
+    # Use proper format for X and y
+    X = torch.tensor(train_df_X.values, dtype=torch.float32)
+    y = torch.tensor(train_df_y.values, dtype=torch.float32).view(-1, 1) 
+    
+    # Define the DNN model
+    class DNNModel(nn.Module):
+        def __init__(self, input_size, hidden_size, output_size, n_hidden, activation_function):
+            super(DNNModel, self).__init__()
+            self.layers = nn.ModuleList()
+            self.activation_function = activation_function
+
+            # Input layer
+            self.layers.append(nn.Linear(input_size, hidden_size))
+            
+            # Hidden layers
+            for _ in range(n_hidden - 1):
+                self.layers.append(nn.Linear(hidden_size, hidden_size))
+            
+            # Output layer
+            self.layers.append(nn.Linear(hidden_size, output_size))
+            
+        def forward(self, x):
+            for i, layer in enumerate(self.layers[:-1]):  # Iterate through hidden layers
+                x = layer(x)
+                if self.activation_function == 'relu':
+                    x = nn.ReLU()(x)
+                elif self.activation_function == 'sigmoid':
+                    x = torch.sigmoid(x)
+                elif self.activation_function == 'tanh':
+                    x = torch.tanh(x)
+            
+            # Apply the output layer without activation function
+            x = self.layers[-1](x)
+            return x
+        
+    # Model initialization
+    input_size = X.shape[1]
+    output_size = y.shape[1]
+    model_dnn = DNNModel(input_size, hidden_size, output_size, n_hidden, activation_function)
+    
+    if solver == 'adam':
+        optimizer = optim.Adam(model_dnn.parameters(), lr=learning_rate)
+    elif solver == 'sgd':
+        optimizer = optim.SGD(model_dnn.parameters(), lr=learning_rate)
+    else:
+        raise ValueError('Solver not found')
+    
+    # Loss function
+    criterion = nn.MSELoss()  # Mean Squared Error loss for regression
+    
+    # TRAIN MODEL
+    # Training loop
+    for epoch in range(epochs):
+        model_dnn.train()
+        
+        # Forward pass
+        output = model_dnn(X)
+        loss = criterion(output, y)
+        
+        # Backward pass
+        optimizer.zero_grad()
+        loss.backward()
+        
+        # Update weights
+        optimizer.step()
+        
+        if epoch % 10 == 0:
+            print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
+  
+    # PACK MODEL
+    model = {"model_dnn": model_dnn}
+  
+    return model
+
+def produce_forecast_m8_dnn(model, train_df_X, test_df_X):
+    """Create forecast at the train and test set using the trained model
+
+    Args:
+        model (dict): all parameters of the trained 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
+    """
+    
+    # UNPACK MODEL
+    model_dnn = model["model_dnn"]
+
+    # PREPARE FORMAT
+    train_df_X_tensor = torch.tensor(train_df_X.values, dtype=torch.float32)
+    test_df_X_tensor = torch.tensor(test_df_X.values, dtype=torch.float32)
+
+    # PRODUCE FORECAST
+    # Switch model to evaluation mode for inference
+    model_dnn.eval()
+
+    # TRAIN SET FORECAST
+    with torch.no_grad():  # Disable gradient calculation to save memory
+        train_df_y_hat_tensor = model_dnn(train_df_X_tensor)
+
+    # TEST SET FORECAST
+    with torch.no_grad():  # Disable gradient calculation to save memory
+        test_df_y_hat_tensor = model_dnn(test_df_X_tensor)
+        
+    # Create DataFrames of result
+    train_df_y_hat = pd.DataFrame(train_df_y_hat_tensor.numpy(), index=train_df_X.index, columns=['y_hat'])
+    test_df_y_hat = pd.DataFrame(test_df_y_hat_tensor.numpy(), index=test_df_X.index, columns=['y_hat'])
+    
+    return train_df_y_hat, test_df_y_hat
+

pynnlf/scaffold/models/m9_rt.py

@@ -0,0 +1,74 @@
+# IMPORT IMPORTANT LIBRARY
+from sklearn.tree import DecisionTreeRegressor
+from sklearn.metrics import mean_squared_error
+import pandas as pd
+
+def train_model_m9_rt(hyperparameter, train_df_X, train_df_y):
+    ''' Train and test a regression tree 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
+    seed = hyperparameter['seed']
+    max_depth = hyperparameter['max_depth']
+    min_samples_split = hyperparameter['min_samples_split']
+    min_samples_leaf = hyperparameter['min_samples_leaf']
+    max_features = hyperparameter['max_features']
+    
+    #TRAIN MODEL
+    # Initialize the regression tree model with important hyperparameters
+    regressor = DecisionTreeRegressor(
+        criterion='squared_error',
+        max_depth=max_depth,
+        min_samples_split = min_samples_split,
+        min_samples_leaf = min_samples_leaf,
+        max_features = max_features,
+        random_state = seed
+    )
+    
+    # Train the model
+    regressor.fit(train_df_X, train_df_y)
+  
+    # PACK MODEL
+    model = {"rt": regressor}
+    
+    # print('I am here after training the model')
+  
+    return model
+
+
+def produce_forecast_m9_rt(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
+    regressor = model['rt']
+    
+    # PRODUCE FORECAST
+    train_df_y_hat = pd.DataFrame(regressor.predict(train_df_X), index = train_df_X.index, columns = ['y_hat'])
+    test_df_y_hat = pd.DataFrame(regressor.predict(test_df_X), index = test_df_X.index, columns = ['y_hat'])
+    
+    # print('I am here after training the model')
+    # print('train_df_y_hat', train_df_y_hat)
+    # print('test_df_y_hat', test_df_y_hat)
+    
+    return train_df_y_hat, test_df_y_hat
+