epftoolbox

https://epftoolbox.readthedocs.io/en/latest/
Admin
epftoolbox is an open-access Python library for electricity price forecasting research with data...
Tokens:34,037
Snippets:201
Trust Score:9.6
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install EPFToolbox using Pip

Source: https://epftoolbox.readthedocs.io/en/latest/modules/started.html

Install the EPFToolbox library locally using pip after cloning the repository.

```bash
pip install .
```

--------------------------------

### Optimize DNN Hyperparameters and Features

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

This example demonstrates how to optimize hyperparameters and select features for the DNN model. It requires specifying dataset paths, optimization parameters like max_evals and nlayers, and calibration window details.

```python
"""
Example for optimizing the hyperparameter and features of the DNN model
"""

# Author: Jesus Lago

# License: AGPL-3.0 License


from epftoolbox.models import hyperparameter_optimizer

# Number of layers in DNN
nlayers = 2

# Market under study. If it not one of the standard ones, the file name
# has to be provided, where the file has to be a csv file
dataset = 'NP'

# Number of years (a year is 364 days) in the test dataset.
years_test = 2

# Optional parameters for selecting the test dataset, if either of them is not provided, 
# the test dataset is built using the years_test parameter. They should either be one of
# the date formats existing in python or a string with the following format
# "%d/%m/%Y %H:%M"
begin_test_date = None
end_test_date = None

# Boolean that selects whether the validation and training datasets are shuffled
shuffle_train = 1

# Boolean that selects whether a data augmentation technique for DNNs is used
data_augmentation = 0

# Boolean that selects whether we start a new hyperparameter optimization or we restart an existing one
new_hyperopt = 1

# Number of years used in the training dataset for recalibration
calibration_window = 4

# Unique identifier to read the trials file of hyperparameter optimization
experiment_id = 1

# Number of iterations for hyperparameter optimization
max_evals = 1500

path_datasets_folder = "./datasets/"
path_hyperparameters_folder = "./experimental_files/"

# Check documentation of the hyperparameter_optimizer for each of the function parameters
# In this example, we optimize a model for the PJM market.
# We consider two directories, one for storing the datasets and the other one for the experimental files.
# We start a hyperparameter optimization from scratch. We employ 1500 iterations in hyperopt,
# 2 years of test data, a DNN with 2 hidden layers, a calibration window of 4 years,
# we avoid data augmentation,  and we provide an experiment_id equal to 1
hyperparameter_optimizer(path_datasets_folder=path_datasets_folder, 
                         path_hyperparameters_folder=path_hyperparameters_folder, 
                         new_hyperopt=new_hyperopt, max_evals=max_evals, nlayers=nlayers, dataset=dataset, 
                         years_test=years_test, calibration_window=calibration_window, 
                         shuffle_train=shuffle_train, data_augmentation=0, experiment_id=experiment_id,
                         begin_test_date=begin_test_date, end_test_date=end_test_date)

```

--------------------------------

### Flexible Recalibration and Forecasting with LEAR Model

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear_examples.html

This example provides a more flexible interface for performing daily recalibration and forecasting using the LEAR model. It is suitable for real-time applications requiring greater control over the forecasting process.

```python
"""
Example for using the LEAR model for forecasting prices with daily recalibration
"""

# Author: Jesus Lago

# License: AGPL-3.0 License

import pandas as pd
import numpy as np
import argparse
import os

from epftoolbox.data import read_data
from epftoolbox.evaluation import MAE, sMAPE
from epftoolbox.models import LEAR

# ------------------------------ EXTERNAL PARAMETERS ------------------------------------#

parser = argparse.ArgumentParser()

parser.add_argument("--dataset", type=str, default='PJM', 
                    help='Market under study. If it not one of the standard ones, the file name' + 
                         'has to be provided, where the file has to be a csv file')

parser.add_argument("--years_test", type=int, default=2, 
                    help='Number of years (a year is 364 days) in the test dataset. Used if ' + 
                    ' begin_test_date and end_test_date are not provided.')

parser.add_argument("--calibration_window", type=int, default=4 * 364, 
                    help='Number of days used in the training dataset for recalibration')

parser.add_argument("--begin_test_date", type=str, default=None, 
                    help='Optional parameter to select the test dataset. Used in combination with ' + 
                         'end_test_date. If either of them is not provided, test dataset is built ' + 
                         'using the years_test parameter. It should either be  a string with the ' + 
                         ' following format d/m/Y H:M')

parser.add_argument("--end_test_date", type=str, default=None, 
                    help='Optional parameter to select the test dataset. Used in combination with ' + 
                         'begin_test_date. If either of them is not provided, test dataset is built ' + 
                         'using the years_test parameter. It should either be  a string with the ' + 
                         ' following format d/m/Y H:M')

args = parser.parse_args()

dataset = args.dataset
years_test = args.years_test
calibration_window = args.calibration_window
begin_test_date = args.begin_test_date
end_test_date = args.end_test_date

path_datasets_folder = os.path.join('.', 'datasets')
path_recalibration_folder = os.path.join('.', 'experimental_files')
    
    
# Defining train and testing data
df_train, df_test = read_data(dataset=dataset, years_test=years_test, path=path_datasets_folder,
                              begin_test_date=begin_test_date, end_test_date=end_test_date)


```

--------------------------------

### Evaluate DNN Model with Easy Recalibration

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

This example provides a simplified interface for evaluating the DNN model with daily recalibration on a test dataset. It assumes prior hyperparameter optimization and requires specifying dataset, test years, and recalibration parameters.

```python
"""
Simplified example for using the DNN model for forecasting prices with daily recalibration
"""

# Author: Jesus Lago

# License: AGPL-3.0 License

from epftoolbox.models import evaluate_dnn_in_test_dataset
import os

# Number of layers in DNN
nlayers = 2

# Market under study. If it not one of the standard ones, the file name
# has to be provided, where the file has to be a csv file
dataset = 'PJM'

# Number of years (a year is 364 days) in the test dataset.
years_test = 2

# Boolean that selects whether the validation and training datasets were shuffled when
# performing the hyperparameter optimization. Note that it does not select whether
# shuffling is used for recalibration as for recalibration the validation and the
# training datasets are always shuffled.
shuffle_train = 1

# Boolean that selects whether a data augmentation technique for DNNs is used
data_augmentation = 0

# Boolean that selects whether we start a new recalibration or we restart an existing one
new_recalibration = 1

# Number of years used in the training dataset for recalibration
calibration_window = 4

# Unique identifier to read the trials file of hyperparameter optimization
experiment_id = 1

# Optional parameters for selecting the test dataset, if either of them is not provided, 
# the test dataset is built using the years_test parameter. They should either be one of
# the date formats existing in python or a string with the following format

```

--------------------------------

### epftoolbox.models.hyperparameter_optimizer

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn/hyperparameter_optimizer.html

Function to optimize the hyperparameters and input features of the DNN. An example on how to use this function is provided here.

```APIDOC
## epftoolbox.models.hyperparameter_optimizer

### Description
Function to optimize the hyperparameters and input features of the DNN. An example on how to use this function is provided here.

### Parameters
#### Path Parameters
- **path_datasets_folder** (str) - Optional - Path to read and store datasets.
- **path_hyperparameters_folder** (str) - Optional - Path to read and store trials files from hyperopt.

#### Query Parameters
- **new_hyperopt** (bool) - Optional - Boolean that decides whether to start a new hyperparameter optimization or re-start an existing one.
- **max_evals** (int) - Optional - Maximum number of iterations for hyperopt.
- **nlayers** (int) - Optional - Number of layers of the DNN model.
- **dataset** (str) - Optional - Name of the dataset/market under study. If it is one one of the standard markets, i.e. "PJM", "NP", "BE", "FR", or "DE", the dataset is automatically downloaded. If the name is different, a dataset with a csv format should be place in the `path_datasets_folder`.
- **years_test** (int) - Optional - Number of years (a year is 364 days) in the test dataset. It is only used if the arguments `begin_test_date` and `end_test_date` are not provided.
- **calibration_window** (int) - Optional - Calibration window used for training the models.
- **shuffle_train** (bool) - Optional - Boolean that selects whether the validation and training datasets are shuffled. Based on empirical results, this configuration does not play a role when selecting the hyperparameters and features. However, it is important when recalibrating the DNN model.
- **data_augmentation** (bool) - Optional - Boolean that selects whether a data augmentation technique for DNNs is used. Based on empirical results, for some markets data augmentation might improve forecasting accuracy at the expense of higher computational costs.
- **experiment_id** (None) - Optional - Unique identifier to save/read the trials file. If not provided, the current date is used as identifier.
- **begin_test_date** (datetime/str) - Optional - Optional parameter to select the test dataset. Used in combination with the argument `end_test_date`. If either of them is not provided, the test dataset is built using the `years_test` argument. `begin_test_date` should either be a string with the following format "%d/%m/%Y %H:%M", or a datetime object.
- **end_test_date** (datetime/str) - Optional - Optional parameter to select the test dataset. Used in combination with the argument `begin_test_date`. If either of them is not provided, the test dataset is built using the `years_test` argument. `end_test_date` should either be a string with the following format "%d/%m/%Y %H:%M", or a datetime object.
```

--------------------------------

### Initialize and Use DataScaler for Normalization

Source: https://epftoolbox.readthedocs.io/en/latest/modules/data_wrangling.html

Demonstrates how to read data, initialize DataScaler for 'Norm' scaling, and apply fit_transform, transform, and inverse_transform methods. This is useful for preparing training and testing datasets.

```python
from epftoolbox.data import read_data
from epftoolbox.data import DataScaler
df_train, df_test = read_data(path='.', dataset='PJM', begin_test_date='01-01-2016', end_test_date='01-02-2016')
Xtrain = df_train.values
Xtest = df_train.values
scaler = DataScaler('Norm')
Xtrain_scaled = scaler.fit_transform(Xtrain)
Xtest_scaled = scaler.transform(Xtest)
Xtrain_inverse = scaler.inverse_transform(Xtrain_scaled)
Xtest_inverse = scaler.inverse_transform(Xtest_scaled)
```

--------------------------------

### Download and Prepare Forecast and Real Price Data

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/mase.html

This snippet demonstrates how to download historical forecast data, read it into a pandas DataFrame, and prepare real price data for evaluation. It includes transforming index to datetime and reshaping data to a 2D format.

```python
>>> from epftoolbox.evaluation import MASE
>>> from epftoolbox.data import read_data
>>> import pandas as pd
>>>
>>> # Download available forecast of the NP market available in the library repository
>>> # These forecasts accompany the original paper
>>> forecast = pd.read_csv('https://raw.githubusercontent.com/jeslago/epftoolbox/master/' +
...                       'forecasts/Forecasts_NP_DNN_LEAR_ensembles.csv', index_col=0)
>>>
>>> # Transforming indices to datetime format
>>> forecast.index = pd.to_datetime(forecast.index)
>>>
>>> # Reading data from the NP market
>>> df_train, df_test = read_data(path='.', dataset='NP', begin_test_date=forecast.index[0],
...                        end_test_date=forecast.index[-1])
Test datasets: 2016-12-27 00:00:00 - 2018-12-24 23:00:00
>>>
>>> # Extracting forecast of DNN ensemble and display
>>> fc_DNN_ensemble = forecast.loc[:, ['DNN Ensemble']]
>>>
>>> # Extracting real price and display
>>> real_price = df_test.loc[:, ['Price']]
>>> real_price_insample = df_train.loc[:, ['Price']]
>>>
>>> # Building the same datasets with shape (ndays, n_prices/day) instead
>>> # of shape (nprices, 1) and display
>>> fc_DNN_ensemble_2D = pd.DataFrame(fc_DNN_ensemble.values.reshape(-1, 24),
...                                   index=fc_DNN_ensemble.index[::24],
...                                   columns=['h' + str(hour) for hour in range(24)])
>>> real_price_2D = pd.DataFrame(real_price.values.reshape(-1, 24),
...                              index=real_price.index[::24],
...                              columns=['h' + str(hour) for hour in range(24)])
>>> real_price_insample_2D = pd.DataFrame(real_price_insample.values.reshape(-1, 24),
...                              index=real_price_insample.index[::24],
...                              columns=['h' + str(hour) for hour in range(24)])
>>>
>>> fc_DNN_ensemble_2D.head()
                   h0         h1         h2  ...        h21        h22        h23
2016-12-27  24.349676  23.127774  22.208617  ...  27.686771  27.045763  25.724071
2016-12-28  25.453866  24.707317  24.452384  ...  29.424558  28.627130  27.321902
2016-12-29  28.209516  27.715400  27.182692  ...  28.473288  27.926241  27.153401
2016-12-30  28.002935  27.467572  27.028558  ...  29.086532  28.518688  27.738548
2016-12-31  25.732282  24.668331  23.951569  ...  26.965008  26.450995  25.637346
>>>
```

--------------------------------

### Initialize DNN Model

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

Instantiates the DNN model with specified hyperparameters and configuration settings. This prepares the model for training and forecasting.

```python
model = DNN(
    experiment_id=experiment_id, path_hyperparameter_folder=path_hyperparameter_folder, nlayers=nlayers, 
    dataset=dataset, years_test=years_test, shuffle_train=shuffle_train, data_augmentation=data_augmentation,
    calibration_window=calibration_window)

```

--------------------------------

### Initialize Forecast DataFrame and Real Values

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

Sets up an empty DataFrame for storing forecast predictions and prepares the actual real values for comparison. This structures the data for the forecasting process.

```python
forecast = pd.DataFrame(index=df_test.index[::24], columns=['h' + str(k) for k in range(24)])
real_values = df_test.loc[:, ['Price']].values.reshape(-1, 24)
real_values = pd.DataFrame(real_values, index=forecast.index, columns=forecast.columns)
```

--------------------------------

### Download and Prepare Forecast Data

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/smape.html

Downloads forecast data from a GitHub repository and prepares it for use with the sMAPE function. This includes reading CSV data, converting indices to datetime, and reading market data.

```python
from epftoolbox.evaluation import sMAPE
from epftoolbox.data import read_data
import pandas as pd

# Download available forecast of the NP market available in the library repository
# These forecasts accompany the original paper
forecast = pd.read_csv('https://raw.githubusercontent.com/jeslago/epftoolbox/master/' +
                       'forecasts/Forecasts_NP_DNN_ensembles.csv', index_col=0)

# Transforming indices to datetime format
forecast.index = pd.to_datetime(forecast.index)

# Reading data from the NP market
_, df_test = read_data(path='.', dataset='NP', begin_test_date=forecast.index[0],
                       end_test_date=forecast.index[-1])
```

--------------------------------

### Download and Prepare Forecast Data

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/mae.html

Downloads historical forecast data for the NP market and prepares it for evaluation. This involves reading a CSV file and converting the index to datetime objects.

```python
from epftoolbox.evaluation import MAE
from epftoolbox.data import read_data
import pandas as pd

# Download available forecast of the NP market available in the library repository
# These forecasts accompany the original paper
forecast = pd.read_csv('https://raw.githubusercontent.com/jeslago/epftoolbox/master/' +
                       'forecasts/Forecasts_NP_DNN_LEAR_ensembles.csv', index_col=0)
```

```python
# Transforming indices to datetime format
forecast.index = pd.to_datetime(forecast.index)

# Reading data from the NP market
_, df_test = read_data(path='.', dataset='NP', begin_test_date=forecast.index[0],
                       end_test_date=forecast.index[-1])
```

```python
# Extracting forecast of DNN ensemble and display
fc_DNN_ensemble = forecast.loc[:, ['DNN Ensemble']]

# Extracting real price and display
real_price = df_test.loc[:, ['Price']]
```

```python
# Building the same datasets with shape (ndays, n_prices/day)
# instead of shape (nprices, 1) and display
fc_DNN_ensemble_2D = pd.DataFrame(fc_DNN_ensemble.values.reshape(-1, 24),
                                  index=fc_DNN_ensemble.index[::24],
                                  columns=['h' + str(hour) for hour in range(24)])
real_price_2D = pd.DataFrame(real_price.values.reshape(-1, 24),
                             index=real_price.index[::24],
                             columns=['h' + str(hour) for hour in range(24)])

```

--------------------------------

### Download and Prepare Forecast Data

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/mape.html

Downloads forecast data and reads corresponding real price data for a specified market and date range. Transforms indices to datetime format and prepares data for evaluation.

```python
from epftoolbox.evaluation import MAPE
from epftoolbox.data import read_data
import pandas as pd

# Download available forecast of the NP market available in the library repository
# These forecasts accompany the original paper
forecast = pd.read_csv('https://raw.githubusercontent.com/jeslago/epftoolbox/master/' +
                      'forecasts/Forecasts_NP_DNN_ensembles.csv', index_col=0)

# Transforming indices to datetime format
forecast.index = pd.to_datetime(forecast.index)

# Reading data from the NP market
_, df_test = read_data(path='.', dataset='NP', begin_test_date=forecast.index[0],
                       end_test_date=forecast.index[-1])

```

--------------------------------

### Prepare Forecast and Real Values DataFrames

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear_examples.html

Initializes an empty DataFrame for forecast values and reshapes the real test values into a format suitable for daily predictions. It also extracts the forecast dates from the DataFrame index.

```python
# Defining empty forecast array and the real values to be predicted in a more friendly format
forecast = pd.DataFrame(index=df_test.index[::24], columns=['h' + str(k) for k in range(24)])
real_values = df_test.loc[:, ['Price']].values.reshape(-1, 24)
real_values = pd.DataFrame(real_values, index=forecast.index, columns=forecast.columns)

forecast_dates = forecast.index
```

--------------------------------

### LEAR Class Constructor

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear/LEAR.html

Initializes the LEAR model with an optional calibration window.

```APIDOC
## Class: LEAR

### Description
Class to build a LEAR model, recalibrate it, and use it to predict DA electricity prices.

### Parameters
#### Optional Parameters
- **calibration_window** (int) - Calibration window (in days) for the LEAR model. Defaults to 1092.
```

--------------------------------

### DNN Class Constructor

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn/DNN.html

Initializes the DNN model for electricity price forecasting. It requires an experiment ID and can be configured with various parameters related to the model architecture, dataset, and training.

```APIDOC
## Class epftoolbox.models.DNN

### Description
DNN for electricity price forecasting. It considers a set of best hyperparameters, it recalibrates a `DNNModel` based on these hyperparameters, and makes new predictions.

### Parameters
* **experiment_id** (str) - Unique identifier to read the trials file.
* **path_hyperparameter_folder** (str, optional) - Path of the folder containing the trials file with the optimal hyperparameters. Defaults to './experimental_files'.
* **nlayers** (int, optional) - Number of layers of the DNN model. Defaults to 2.
* **dataset** (str, optional) - Name of the dataset/market under study. Defaults to 'PJM'.
* **years_test** (int, optional) - Number of years (a year is 364 days) in the test dataset. Defaults to 2.
* **shuffle_train** (bool, optional) - Boolean that selects whether the validation and training datasets were shuffled when performing the hyperparameter optimization. Defaults to 1.
* **data_augmentation** (bool, optional) - Boolean that selects whether a data augmentation technique for electricity price forecasting is employed. Defaults to 0.
* **calibration_window** (int, optional) - Number of days used in the training/validation dataset for recalibration. Defaults to 4.
```

--------------------------------

### Download and Prepare Data for rMAE Calculation

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/rmae.html

Downloads forecast data and real prices, then preprocesses them into the required formats for rMAE calculation. This includes converting indices to datetime and reshaping data into 2D DataFrames.

```python
from epftoolbox.evaluation import rMAE
from epftoolbox.data import read_data
import pandas as pd

# Download available forecast of the NP market available in the library repository
# These forecasts accompany the original paper
forecast = pd.read_csv('https://raw.githubusercontent.com/jeslago/epftoolbox/master/' +
                       'forecasts/Forecasts_NP_DNN_ensembles.csv', index_col=0)

# Transforming indices to datetime format
forecast.index = pd.to_datetime(forecast.index)

# Reading data from the NP market
_, df_test = read_data(path='.', dataset='NP', begin_test_date=forecast.index[0],
                       end_test_date=forecast.index[-1])

# Extracting forecast of DNN ensemble and display
fc_DNN_ensemble = forecast.loc[:, ['DNN Ensemble']]

# Extracting real price and display
real_price = df_test.loc[:, ['Price']]

# Building the same datasets with shape (ndays, n_prices/day) instead
# of shape (nprices, 1) and display
fc_DNN_ensemble_2D = pd.DataFrame(fc_DNN_ensemble.values.reshape(-1, 24),
                                  index=fc_DNN_ensemble.index[::24],
                                  columns=['h' + str(hour) for hour in range(24)])
real_price_2D = pd.DataFrame(real_price.values.reshape(-1, 24),
                             index=real_price.index[::24],
                             columns=['h' + str(hour) for hour in range(24)])

```

--------------------------------

### recalibrate_and_forecast_next_day

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn/DNN.html

Builds an easy-to-use interface for daily recalibration and forecasting of the DNN model.

```APIDOC
## recalibrate_and_forecast_next_day(df, next_day_date)

### Description
Method that builds an easy-to-use interface for daily recalibration and forecasting of the DNN model. The method receives a pandas dataframe `df` and a day `next_day_date`. Then, it recalibrates the model using data up to the day before `next_day_date` and makes a prediction for day `next_day_date`.

### Parameters
* **df** (pandas.DataFrame) - Dataframe of historical data containing prices and N exogenous inputs. The index of the dataframe should be dates with hourly frequency. The columns should have the following names [‘Price’, ‘Exogenous 1’, ‘Exogenous 2’, …., ‘Exogenous N’].
* **next_day_date** (TYPE) - Date of the day-ahead.

### Returns
* An array containing the predictions in the provided date.

### Return Type
numpy.array
```

--------------------------------

### DNN Forecasting with Daily Recalibration Script

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

This Python script demonstrates a flexible interface for using the DNN model for price forecasting with daily recalibration. It parses command-line arguments to configure the model and dataset, assuming hyperparameter optimization has been previously performed.

```python

# Author: Jesus Lago

# License: AGPL-3.0 License

import pandas as pd
import numpy as np
import argparse
import os

from epftoolbox.data import read_data
from epftoolbox.evaluation import MAE, sMAPE
from epftoolbox.models import DNN



# ------------------------------ EXTERNAL PARAMETERS ------------------------------------#

parser = argparse.ArgumentParser()

parser.add_argument("--nlayers", help="Number of layers in DNN", type=int, default=2)

parser.add_argument("--dataset", type=str, default='PJM', 
                    help='Market under study. If it not one of the standard ones, the file name' + 
                         'has to be provided, where the file has to be a csv file')

parser.add_argument("--years_test", type=int, default=2, 
                    help='Number of years (a year is 364 days) in the test dataset. Used if ' + 
                    ' begin_test_date and end_test_date are not provided.')

parser.add_argument("--shuffle_train", type=int, default=1, 
                    help='Boolean that selects whether the validation and training datasets were' + 
                    ' shuffled when performing the hyperparameter optimization.')

parser.add_argument("--data_augmentation", type=int, default=0, 
                    help='Boolean that selects whether a data augmentation technique for DNNs is used')

parser.add_argument("--new_recalibration", type=int, default=1, 
                    help='Boolean that selects whether we start a new recalibration or we restart an' + 
                         ' existing one')

parser.add_argument("--calibration_window", type=int, default=4, 
                    help='Number of years used in the training dataset for recalibration')

parser.add_argument("--experiment_id", type=int, default=1, 
                    help='Unique identifier to read the trials file of hyperparameter optimization')

parser.add_argument("--begin_test_date", type=str, default=None, 
                    help='Optional parameter to select the test dataset. Used in combination with ' + 
                         'end_test_date. If either of them is not provided, test dataset is built ' + 
                         'using the years_test parameter. It should either be  a string with the ' + 
                         ' following format d/m/Y H:M')

parser.add_argument("--end_test_date", type=str, default=None, 
                    help='Optional parameter to select the test dataset. Used in combination with ' + 
                         'begin_test_date. If either of them is not provided, test dataset is built ' + 
                         'using the years_test parameter. It should either be  a string with the ' + 
                         ' following format d/m/Y H:M')

args = parser.parse_args()

nlayers = args.nlayers
dataset = args.dataset
years_test = args.years_test
shuffle_train = args.shuffle_train
data_augmentation = args.data_augmentation
new_recalibration = args.new_recalibration
calibration_window = args.calibration_window
experiment_id = args.experiment_id
begin_test_date = args.begin_test_date
end_test_date = args.end_test_date

path_datasets_folder = os.path.join('.', 'datasets')
path_recalibration_folder = os.path.join('.', 'experimental_files')
path_hyperparameter_folder = os.path.join('.', 'experimental_files')
    
```

--------------------------------

### Clone EPFToolbox Repository

Source: https://epftoolbox.readthedocs.io/en/latest/modules/started.html

Clone the EPFToolbox library from GitHub to your local machine.

```bash
git clone https://github.com/jeslago/epftoolbox.git
cd epftoolbox
```

--------------------------------

### Prepare Forecast and Real Price DataFrames

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/smape.html

Extracts specific forecast columns and real price data, then reshapes them into a 2D format (ndays, n_prices/day) for compatibility with the sMAPE function.

```python
# Extracting forecast of DNN ensemble and display
fc_DNN_ensemble = forecast.loc[:, ['DNN Ensemble']]

# Extracting real price and display
real_price = df_test.loc[:, ['Price']]

# Building the same datasets with shape (ndays, n_prices/day) instead
# of shape (nprices, 1) and display
fc_DNN_ensemble_2D = pd.DataFrame(fc_DNN_ensemble.values.reshape(-1, 24),
                                  index=fc_DNN_ensemble.index[::24],
                                  columns=['h' + str(hour) for hour in range(24)])
real_price_2D = pd.DataFrame(real_price.values.reshape(-1, 24),
                             index=real_price.index[::24],
                             columns=['h' + str(hour) for hour in range(24)])
fc_DNN_ensemble_2D.head()
```

--------------------------------

### LEAR Model Calibration and Forecasting Loop

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear_examples.html

Iterates through forecast dates, preparing available data by excluding future prices. It then recalibrates the LEAR model and forecasts the next day's prices, saving the predictions and computing performance metrics (sMAPE, MAE) at each step.

```python
model = LEAR(calibration_window=calibration_window)

# For loop over the recalibration dates
for date in forecast_dates:

    # For simulation purposes, we assume that the available data is
    # the data up to current date where the prices of current date are not known
    data_available = pd.concat([df_train, df_test.loc[:date + pd.Timedelta(hours=23), :]], axis=0)

    # We set the real prices for current date to NaN in the dataframe of available data
    data_available.loc[date:date + pd.Timedelta(hours=23), 'Price'] = np.NaN

    # Recalibrating the model with the most up-to-date available data and making a prediction
    # for the next day
    Yp = model.recalibrate_and_forecast_next_day(df=data_available, next_day_date=date, 
                                                 calibration_window=calibration_window)
    # Saving the current prediction
    forecast.loc[date, :] = Yp

    # Computing metrics up-to-current-date
    mae = np.mean(MAE(forecast.loc[:date].values.squeeze(), real_values.loc[:date].values))
    smape = np.mean(sMAPE(forecast.loc[:date].values.squeeze(), real_values.loc[:date].values)) * 100

    # Pringint information
    print('{} - sMAPE: {:.2f}%  |  MAE: {:.3f}'.format(str(date)[:10], smape, mae))

    # Saving forecast
    forecast.to_csv(forecast_file_path)
```

--------------------------------

### Define Forecast File Name and Path

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear_examples.html

Constructs a unique filename for saving forecast data based on dataset, test years, and calibration window. It then joins this filename with a specified folder path to create the full forecast file path.

```python
forecast_file_name = 'fc_nl' + '_dat' + str(dataset) + '_YT' + str(years_test) + \
                     '_CW' + str(calibration_window) + '.csv'

forecast_file_path = os.path.join(path_recalibration_folder, forecast_file_name)
```

--------------------------------

### recalibrate_and_forecast_next_day(df, calibration_window, next_day_date)

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear/LEAR.html

Provides an easy interface for daily recalibration and forecasting of the LEAR model for the next day.

```APIDOC
## Method: recalibrate_and_forecast_next_day

### Description
Easy-to-use interface for daily recalibration and forecasting of the LEAR model. The function receives a pandas dataframe and a date. Usually, the data should correspond with the date of the next-day when using for daily recalibration.

### Parameters
#### Path Parameters
- **df** (pandas.DataFrame) - Dataframe of historical data containing prices and N exogenous inputs. The index of the dataframe should be dates with hourly frequency. The columns should have the following names ['Price', 'Exogenous 1', 'Exogenous 2', ...., 'Exogenous N'].
- **calibration_window** (int) - Calibration window (in days) for the LEAR model.
- **next_day_date** (datetime) - Date of the day-ahead.

### Returns
- **numpy.array** - The prediction of day-ahead prices.
```

--------------------------------

### Evaluate DNN Model with Daily Recalibration

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

This script evaluates a pre-trained DNN model on a test dataset, incorporating daily recalibration. It requires setting up various paths and parameters related to the dataset, model architecture, and recalibration process.

```python
# Set up the paths for saving data (this are the defaults for the library)
path_datasets_folder = os.path.join('.', 'datasets')
path_recalibration_folder = os.path.join('.', 'experimental_files')
path_hyperparameter_folder = os.path.join('.', 'experimental_files')

evaluate_dnn_in_test_dataset(experiment_id, path_hyperparameter_folder=path_hyperparameter_folder, 
                               path_datasets_folder=path_datasets_folder, shuffle_train=shuffle_train, 
                               path_recalibration_folder=path_recalibration_folder, 
                               nlayers=nlayers, dataset=dataset, years_test=years_test, 
                               data_augmentation=data_augmentation, calibration_window=calibration_window, 
                               new_recalibration=new_recalibration, begin_test_date=begin_test_date, 
                               end_test_date=end_test_date)
```

--------------------------------

### Naive Forecast Implementation

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics.html

Provides a naive forecast implementation used for calculating MASE and rMAE metrics. This is a foundational component for scaled error metrics.

```python
def naive_forecast(data: np.ndarray) -> np.ndarray:
    """Naive forecast for one-step ahead prediction.

    Args:
        data (np.ndarray): Input time series data.

    Returns:
        np.ndarray: Naive forecast for the next step.
    """
    return np.roll(data, 1)
```

--------------------------------

### Load Existing Forecast and Check Progress

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

Imports previously saved forecast data and identifies dates that still need forecasting by checking for NaN values. This allows resuming interrupted recalibration processes.

```python
forecast = pd.read_csv(forecast_file_path, index_col=0)
forecast.index = pd.to_datetime(forecast.index)

forecast_dates = forecast[forecast.isna().any(axis=1)].index

if len(forecast_dates) == 0:

    mae = np.mean(MAE(forecast.values.squeeze(), real_values.values))
    smape = np.mean(sMAPE(forecast.values.squeeze(), real_values.values)) * 100
    print('{} - sMAPE: {:.2f}%  |  MAE: {:.3f}'.format('Final metrics', smape, mae))
```

--------------------------------

### Recalibrate and Forecast Next Day

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

Iterates through forecast dates, recalibrates the DNN model with available data, and predicts prices for the next day. It also computes and prints metrics for the forecasted period.

```python
for date in forecast_dates:

    data_available = pd.concat([df_train, df_test.loc[:date + pd.Timedelta(hours=23), :]], axis=0)

    data_available.loc[date:date + pd.Timedelta(hours=23), 'Price'] = np.NaN

    Yp = model.recalibrate_and_forecast_next_day(df=data_available, next_day_date=date)

    forecast.loc[date, :] = Yp

    mae = np.mean(MAE(forecast.loc[:date].values.squeeze(), real_values.loc[:date].values)) 
    smape = np.mean(sMAPE(forecast.loc[:date].values.squeeze(), real_values.loc[:date].values)) * 100

    print('{} - sMAPE: {:.2f}%  |  MAE: {:.3f}'.format(str(date)[:10], smape, mae))

    forecast.to_csv(forecast_file_path)
```

--------------------------------

### epftoolbox.evaluation.naive_forecast

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/naive.html

Builds a naive forecast for electricity price forecasting, used for computing MASE and RMAE accuracy metrics. It supports daily, weekly, or a hybrid seasonality.

```APIDOC
## naive_forecast(p_real, m=None, n_prices_day=24)

### Description
Function to build the naive forecast for electricity price forecasting. The function is used to compute the accuracy metrics MASE and RMAE.

### Method
Function Call

### Parameters
#### Path Parameters
- **p_real** (pandas.DataFrame) – Dataframe containing the real prices. It must be of shape (nprices,1).
- **m** (int, optional) – Index that specifies the seasonality in the naive forecast. It can be 'D' for daily seasonality, 'W' for weekly seasonality, or None for the standard naive forecast in electricity price forecasting, i.e. daily seasonality for Tuesday to Friday and weekly seasonality for Saturday to Monday.
- **n_prices_day** (int, optional) – Number of prices in a day. Usually this value is 24 for most day-ahead markets

### Returns
#### Success Response
- **Return type**: pandas.DataFrame - Dataframe containing the predictions of the naive forecast.

### Response Example
{
  "example": "pandas.DataFrame"
}
```

--------------------------------

### Naive Forecast Function Signature

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/naive.html

This is the function signature for naive_forecast. It outlines the parameters for real prices, seasonality index, and the number of prices per day.

```python
epftoolbox.evaluation.naive_forecast(p_real, m=None, n_prices_day=24)
```

--------------------------------

### Prepare 2D DataFrames for MAPE Calculation

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/mape.html

Reshapes forecast and real price data into a 2D format (ndays, n_prices/day) for MAPE calculation. This is useful when the input data is initially in a (nprices, 1) format.

```python
# Extracting forecast of DNN ensemble and display
fc_DNN_ensemble = forecast.loc[:, ['DNN Ensemble']]

# Extracting real price and display
real_price = df_test.loc[:, ['Price']]

# Building the same datasets with shape (ndays, n_prices/day) instead
# of shape (nprices, 1) and display
fc_DNN_ensemble_2D = pd.DataFrame(fc_DNN_ensemble.values.reshape(-1, 24),
                                  index=fc_DNN_ensemble.index[::24],
                                  columns=['h' + str(hour) for hour in range(24)])
real_price_2D = pd.DataFrame(real_price.values.reshape(-1, 24),
                             index=real_price.index[::24],
                             columns=['h' + str(hour) for hour in range(24)])

```

--------------------------------

### Generate Forecast File Name

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

Constructs a unique filename for saving forecast results based on various configuration parameters. This ensures organized storage of predictions.

```python
forecast_file_name = 'fc_nl' + str(nlayers) + '_dat' + str(dataset) + \
                   '_YT' + str(years_test) + '_SF' + str(shuffle_train) + \
                   '_DA' * data_augmentation + '_CW' + str(calibration_window) + \
                   '_' + str(experiment_id) + '.csv'
```

--------------------------------

### Evaluate LEAR Model in Test Dataset

Source: https://epftoolbox.readthedocs.io/en/latest/modules/lear_examples.html

Use this simplified interface for evaluating the LEAR model on a given test dataset. It offers a straightforward way to assess LEAR model performance across different datasets.

```python
"""
Simplified example for using the LEAR model for forecasting prices with daily recalibration
"""

# Author: Jesus Lago

# License: AGPL-3.0 License

from epftoolbox.models import evaluate_lear_in_test_dataset
import os

# Market under study. If it not one of the standard ones, the file name
# has to be provided, where the file has to be a csv file
dataset = 'PJM'

# Number of years (a year is 364 days) in the test dataset.
years_test = 2

# Number of days used in the training dataset for recalibration
calibration_window = 364 * 4

# Optional parameters for selecting the test dataset, if either of them is not provided, 
# the test dataset is built using the years_test parameter. They should either be one of
# the date formats existing in python or a string with the following format
# "%d/%m/%Y %H:%M"
begin_test_date = None
end_test_date = None

path_datasets_folder = os.path.join('.', 'datasets')
path_recalibration_folder = os.path.join('.', 'experimental_files')
    
evaluate_lear_in_test_dataset(path_recalibration_folder=path_recalibration_folder, 
                             path_datasets_folder=path_datasets_folder, dataset=dataset, years_test=years_test, 
                             calibration_window=calibration_window, begin_test_date=begin_test_date, 
                             end_test_date=end_test_date)

```

--------------------------------

### DNNModel Constructor

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn/DNNModel.html

Initializes a DNNModel object. This class provides a basic DNN model that can be trained and used for predictions. It is often used internally by other classes like `hyperparameter_optimizer` and `DNN`.

```APIDOC
## DNNModel Constructor

### Description
Initializes a DNNModel object. This class provides a basic DNN model that can be trained and used for predictions. It is often used internally by other classes like `hyperparameter_optimizer` and `DNN`.

### Parameters

* **neurons** (list) - List containing the number of neurons in each hidden layer. E.g. if `len(neurons)` is 2, the DNN model has an input layer of size `n_features`, two hidden layers, and an output layer of size `outputShape`.
* **n_features** (int) - Number of input features in the model. This number defines the size of the input layer.
* **outputShape** (int, optional) - Default number of output neurons. Defaults to 24.
* **dropout** (float, optional) - Number between [0, 1] that selects the percentage of dropout. A value of 0 indicates no dropout.
* **batch_normalization** (bool, optional) - Boolean that selects whether batch normalization is considered.
* **lr** (float, optional) - Learning rate for optimizer algorithm. If none provided, the default one is employed.
* **verbose** (bool, optional) - Boolean that controls the logs. If set to true, a minimum amount of information is displayed.
* **epochs_early_stopping** (int, optional) - Number of epochs used in early stopping to stop training. When no improvement is observed in the validation dataset after `epochs_early_stopping` epochs, the training stops.
* **scaler** (epftoolbox.data.DataScaler, optional) - Scaler object to invert-scale the output of the neural network if the neural network is trained with scaled outputs.
* **loss** (str, optional) - Loss to be used when training the neural network. Any of the regression losses defined in keras can be used.
* **optimizer** (str, optional) - Name of the optimizer when training the DNN. See the keras documentation for a list of optimizers.
* **activation** (str, optional) - Name of the activation function in the hidden layers. See the keras documentation for a list of activation function.
* **initializer** (str, optional) - Name of the initializer function for the weights of the neural network. See the keras documentation for a list of initializer functions.
* **regularization** (None, optional) - Name of the regularization technique. It can have three values 'l2' for l2-norm regularization, 'l1' for l1-norm regularization, or None for no regularization.
* **lambda_reg** (int, optional) - The weight for regularization if `regularization` is 'l2' or 'l1'.
```

--------------------------------

### Define Training and Testing Data

Source: https://epftoolbox.readthedocs.io/en/latest/modules/dnn_examples.html

Reads data for training and testing from a specified dataset and date range. This is a prerequisite for model training and evaluation.

```python
df_train, df_test = read_data(dataset=dataset, years_test=years_test, path=path_datasets_folder,
                              begin_test_date=begin_test_date, end_test_date=end_test_date)
```

--------------------------------

### Evaluate MASE with NumPy Arrays (1D)

Source: https://epftoolbox.readthedocs.io/en/latest/modules/metrics/mase.html

Use this snippet to evaluate MASE when real prices, forecasts, and in-sample real prices are provided as 1D NumPy arrays. Specify the frequency 'W' for weekly data and '1H' for hourly frequency.

```python
MASE(p_pred=fc_DNN_ensemble.values, p_real=real_price.values,
     p_real_in=real_price_insample.values, m='W', freq='1H')
```
Tokens:
Raw