emhass 0.8.6__py3-none-any.whl → 0.9.1__py3-none-any.whl

emhass/forecast.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import pathlib
+import os
 import pickle
 import copy
 import logging
@@ -23,7 +24,7 @@ from pvlib.irradiance import disc
 
 from emhass.retrieve_hass import RetrieveHass
 from emhass.machine_learning_forecaster import MLForecaster
-from emhass.utils import get_days_list, get_root, set_df_index_freq
+from emhass.utils import get_days_list, set_df_index_freq
 
 
 class Forecast(object):
@@ -98,25 +99,25 @@ class Forecast(object):
     """
 
     def __init__(self, retrieve_hass_conf: dict, optim_conf: dict, plant_conf: dict, 
-                 params: str, base_path: str, logger: logging.Logger, 
+                 params: str, emhass_conf: dict, logger: logging.Logger, 
                  opt_time_delta: Optional[int] = 24,
                  get_data_from_file: Optional[bool] = False) -> None:
         """
         Define constructor for the forecast class.
         
-        :param retrieve_hass_conf: Dictionnary containing the needed configuration
+        :param retrieve_hass_conf: Dictionary containing the needed configuration
             data from the configuration file, specific to retrieve data from HASS
         :type retrieve_hass_conf: dict
-        :param optim_conf: Dictionnary containing the needed configuration
+        :param optim_conf: Dictionary containing the needed configuration
             data from the configuration file, specific for the optimization task
         :type optim_conf: dict
-        :param plant_conf: Dictionnary containing the needed configuration
+        :param plant_conf: Dictionary containing the needed configuration
             data from the configuration file, specific for the modeling of the PV plant
         :type plant_conf: dict
         :param params: Configuration parameters passed from data/options.json
         :type params: str
-        :param base_path: The path to the yaml configuration file
-        :type base_path: str
+        :param emhass_conf: Dictionary containing the needed emhass paths
+        :type emhass_conf: dict
         :param logger: The passed logger object
         :type logger: logging object
         :param opt_time_delta: The time delta in hours used to generate forecasts, 
@@ -141,7 +142,7 @@ class Forecast(object):
         self.var_load_new = self.var_load+'_positive'
         self.lat = self.retrieve_hass_conf['lat'] 
         self.lon = self.retrieve_hass_conf['lon']
-        self.root = base_path
+        self.emhass_conf = emhass_conf
         self.logger = logger
         self.get_data_from_file = get_data_from_file
         self.var_load_cost = 'unit_load_cost'
@@ -169,7 +170,7 @@ class Forecast(object):
         
         
     def get_weather_forecast(self, method: Optional[str] = 'scrapper',
-                             csv_path: Optional[str] = "/data/data_weather_forecast.csv") -> pd.DataFrame:
+                             csv_path: Optional[str] = "data_weather_forecast.csv") -> pd.DataFrame:
         r"""
         Get and generate weather forecast data.
         
@@ -180,6 +181,8 @@ class Forecast(object):
         :rtype: pd.DataFrame
         
         """
+        csv_path  = self.emhass_conf['data_path'] / csv_path
+
         self.logger.info("Retrieving weather forecast data using method = "+method)
         self.weather_forecast_method = method # Saving this attribute for later use to identify csv method usage
         if method == 'scrapper':
@@ -292,7 +295,7 @@ class Forecast(object):
                 else:
                     data = data + data_tmp
         elif method == 'csv': # reading from a csv file
-            weather_csv_file_path = self.root + csv_path
+            weather_csv_file_path = csv_path
             # Loading the csv file, we will consider that this is the PV power in W
             data = pd.read_csv(weather_csv_file_path, header=None, names=['ts', 'yhat'])
             # Check if the passed data has the correct length       
@@ -414,9 +417,9 @@ class Forecast(object):
                 # Setting the main parameters of the PV plant
                 location = Location(latitude=self.lat, longitude=self.lon)
                 temp_params = TEMPERATURE_MODEL_PARAMETERS['sapm']['close_mount_glass_glass']
-                cec_modules = bz2.BZ2File(get_root(__file__, num_parent=2) / 'emhass/data/cec_modules.pbz2', "rb")
+                cec_modules =  bz2.BZ2File(pathlib.Path(__file__).parent / 'data/cec_modules.pbz2', "rb")
                 cec_modules = cPickle.load(cec_modules)
-                cec_inverters = bz2.BZ2File(get_root(__file__, num_parent=2) / 'emhass/data/cec_inverters.pbz2', "rb")
+                cec_inverters = bz2.BZ2File(pathlib.Path(__file__).parent / 'data/cec_inverters.pbz2', "rb")
                 cec_inverters = cPickle.load(cec_inverters)
                 if type(self.plant_conf['module_model']) == list:
                     P_PV_forecast = pd.Series(0, index=df_weather.index)
@@ -518,7 +521,9 @@ class Forecast(object):
             else:
                 days_list = df_csv.index.day.unique().tolist()
         else:
-            load_csv_file_path = self.root + csv_path
+            if not os.path.exists(csv_path):
+                csv_path = self.emhass_conf['data_path'] / csv_path
+            load_csv_file_path = csv_path    
             df_csv = pd.read_csv(load_csv_file_path, header=None, names=['ts', 'yhat'])
             df_csv.index = forecast_dates_csv
             df_csv.drop(['ts'], axis=1, inplace=True)
@@ -572,7 +577,7 @@ class Forecast(object):
         return forecast_out
     
     def get_load_forecast(self, days_min_load_forecast: Optional[int] = 3, method: Optional[str] = 'naive',
-                          csv_path: Optional[str] = "/data/data_load_forecast.csv",
+                          csv_path: Optional[str] = "data_load_forecast.csv",
                           set_mix_forecast:Optional[bool] = False, df_now:Optional[pd.DataFrame] = pd.DataFrame(),
                           use_last_window: Optional[bool] = True, mlf: Optional[MLForecaster] = None,
                           debug: Optional[bool] = False) -> pd.Series:
@@ -610,6 +615,8 @@ class Forecast(object):
         :rtype: pd.DataFrame
 
         """
+        csv_path  = self.emhass_conf['data_path'] / csv_path
+        
         if method == 'naive' or method == 'mlforecaster': # retrieving needed data for these methods
             self.logger.info("Retrieving data from hass for load forecast using method = "+method)
             var_list = [self.var_load]
@@ -618,18 +625,24 @@ class Forecast(object):
             time_zone_load_foreacast = None
             # We will need to retrieve a new set of load data according to the days_min_load_forecast parameter
             rh = RetrieveHass(self.retrieve_hass_conf['hass_url'], self.retrieve_hass_conf['long_lived_token'], 
-                               self.freq, time_zone_load_foreacast, self.params, self.root, self.logger)
+                               self.freq, time_zone_load_foreacast, self.params, self.emhass_conf, self.logger)
             if self.get_data_from_file:
-                with open(pathlib.Path(self.root) / 'data' / 'test_df_final.pkl', 'rb') as inp:
-                    rh.df_final, days_list, _ = pickle.load(inp)
+                filename_path = self.emhass_conf['data_path'] / 'test_df_final.pkl'
+                with open(filename_path, 'rb') as inp:
+                    rh.df_final, days_list, var_list = pickle.load(inp)
+                    self.var_load = var_list[0]
+                    self.retrieve_hass_conf['var_load'] = self.var_load
+                    var_interp = [var_list[0]]
+                    self.var_list = [var_list[0]]
+                    self.var_load_new = self.var_load+'_positive'
             else:
                 days_list = get_days_list(days_min_load_forecast) 
                 if not rh.get_data(days_list, var_list):
                     return False
-            if  not rh.prepare_data(self.retrieve_hass_conf['var_load'], load_negative = self.retrieve_hass_conf['load_negative'],
-                            set_zero_min = self.retrieve_hass_conf['set_zero_min'], 
-                            var_replace_zero = var_replace_zero, 
-                            var_interp = var_interp):
+            if  not rh.prepare_data(
+                self.retrieve_hass_conf['var_load'], load_negative = self.retrieve_hass_conf['load_negative'],
+                set_zero_min = self.retrieve_hass_conf['set_zero_min'], 
+                var_replace_zero = var_replace_zero, var_interp = var_interp):
                 return False
             df = rh.df_final.copy()[[self.var_load_new]]
         if method == 'naive': # using a naive approach
@@ -643,13 +656,14 @@ class Forecast(object):
             # Load model
             model_type = self.params['passed_data']['model_type']
             filename = model_type+'_mlf.pkl'
-            filename_path = pathlib.Path(self.root) / filename
+            filename_path = self.emhass_conf['data_path'] / filename
             if not debug:
                 if filename_path.is_file():
                     with open(filename_path, 'rb') as inp:
                         mlf = pickle.load(inp)
                 else:
                     self.logger.error("The ML forecaster file was not found, please run a model fit method before this predict method")
+                    return False
             # Make predictions
             if use_last_window:
                 data_last_window = copy.deepcopy(df)
@@ -657,8 +671,15 @@ class Forecast(object):
             else:
                 data_last_window = None
             forecast_out = mlf.predict(data_last_window)
-            # Force forecast_out length to avoid mismatches
-            forecast_out = forecast_out.iloc[0:len(self.forecast_dates)]
+            # Force forecast length to avoid mismatches
+            self.logger.debug("Number of ML predict forcast data generated (lags_opt): " + str(len(forecast_out.index)))
+            self.logger.debug("Number of forcast dates obtained: " + str(len(self.forecast_dates)))
+            if len(self.forecast_dates) < len(forecast_out.index):
+                forecast_out = forecast_out.iloc[0:len(self.forecast_dates)]
+            # To be removed once bug is fixed
+            elif len(self.forecast_dates) > len(forecast_out.index):
+                self.logger.error("Unable to obtain: " + str(len(self.forecast_dates))  + " lags_opt values from sensor: power load no var loads, check optimization_time_step/freq and historic_days_to_retrieve/days_to_retrieve parameters")
+                return False
             # Define DataFrame
             data_dict = {'ts':self.forecast_dates, 'yhat':forecast_out.values.tolist()}
             data = pd.DataFrame.from_dict(data_dict)
@@ -666,7 +687,7 @@ class Forecast(object):
             data.set_index('ts', inplace=True)
             forecast_out = data.copy().loc[self.forecast_dates]
         elif method == 'csv': # reading from a csv file
-            load_csv_file_path = self.root + csv_path
+            load_csv_file_path = csv_path
             df_csv = pd.read_csv(load_csv_file_path, header=None, names=['ts', 'yhat'])
             if len(df_csv) < len(self.forecast_dates):
                 self.logger.error("Passed data from CSV is not long enough")
@@ -683,6 +704,7 @@ class Forecast(object):
             # Check if the passed data has the correct length
             if len(data_list) < len(self.forecast_dates) and self.params['passed_data']['prediction_horizon'] is None:
                 self.logger.error("Passed data from passed list is not long enough")
+                return False
             else:
                 # Ensure correct length
                 data_list = data_list[0:len(self.forecast_dates)]
@@ -694,6 +716,7 @@ class Forecast(object):
                 forecast_out = data.copy().loc[self.forecast_dates]
         else:
             self.logger.error("Passed method is not valid")
+            return False
         P_Load_forecast = copy.deepcopy(forecast_out['yhat'])
         if set_mix_forecast:
             P_Load_forecast = Forecast.get_mix_forecast(
@@ -723,6 +746,7 @@ class Forecast(object):
         :rtype: pd.DataFrame
 
         """
+        csv_path  = self.emhass_conf['data_path'] / csv_path
         if method == 'hp_hc_periods':
             df_final[self.var_load_cost] = self.optim_conf['load_cost_hc']
             list_df_hp = []
@@ -742,6 +766,7 @@ class Forecast(object):
             # Check if the passed data has the correct length
             if len(data_list) < len(self.forecast_dates) and self.params['passed_data']['prediction_horizon'] is None:
                 self.logger.error("Passed data from passed list is not long enough")
+                return False
             else:
                 # Ensure correct length
                 data_list = data_list[0:len(self.forecast_dates)]
@@ -753,12 +778,13 @@ class Forecast(object):
                 df_final[self.var_load_cost] = forecast_out
         else:
             self.logger.error("Passed method is not valid")
-            
+            return False
         return df_final
     
     def get_prod_price_forecast(self, df_final: pd.DataFrame, method: Optional[str] = 'constant',
-                                csv_path: Optional[str] = "/data/data_prod_price_forecast.csv",
+                                csv_path: Optional[str] = "data_prod_price_forecast.csv", 
                                 list_and_perfect: Optional[bool] = False) -> pd.DataFrame:
+
         r"""
         Get the unit power production price for the energy injected to the grid.\
         This is the price of the energy injected to the utility in a vector \
@@ -779,13 +805,13 @@ class Forecast(object):
         :rtype: pd.DataFrame
 
         """
+        csv_path  = self.emhass_conf['data_path'] / csv_path
         if method == 'constant':
             df_final[self.var_prod_price] = self.optim_conf['prod_sell_price']
         elif method == 'csv':
             forecast_dates_csv = self.get_forecast_days_csv(timedelta_days=0)
-            forecast_out = self.get_forecast_out_from_csv_or_list(df_final,
-                                                          forecast_dates_csv,
-                                                          csv_path)
+            forecast_out = self.get_forecast_out_from_csv_or_list(
+                df_final, forecast_dates_csv, csv_path)
             df_final[self.var_prod_price] = forecast_out
         elif method == 'list': # reading a list of values
             # Loading data from passed list
@@ -793,6 +819,7 @@ class Forecast(object):
             # Check if the passed data has the correct length
             if len(data_list) < len(self.forecast_dates) and self.params['passed_data']['prediction_horizon'] is None:
                 self.logger.error("Passed data from passed list is not long enough")
+                return False
             else:
                 # Ensure correct length
                 data_list = data_list[0:len(self.forecast_dates)]
@@ -804,6 +831,6 @@ class Forecast(object):
                 df_final[self.var_prod_price] = forecast_out
         else:
             self.logger.error("Passed method is not valid")
-            
+            return False
         return df_final
     

emhass/machine_learning_forecaster.py

@@ -38,7 +38,7 @@ class MLForecaster:
     """
 
     def __init__(self, data: pd.DataFrame, model_type: str, var_model: str, sklearn_model: str,
-                 num_lags: int, root: str, logger: logging.Logger) -> None:
+                 num_lags: int, emhass_conf: dict, logger: logging.Logger) -> None:
         r"""Define constructor for the forecast class.
 
         :param data: The data that will be used for train/test
@@ -56,8 +56,8 @@ class MLForecaster:
             is to fix this as one day. For example if your time step is 30 minutes, then fix this \
             to 48, if the time step is 1 hour the fix this to 24 and so on.
         :type num_lags: int
-        :param root: The parent folder of the path where the config.yaml file is located
-        :type root: str
+        :param emhass_conf: Dictionary containing the needed emhass paths
+        :type emhass_conf: dict
         :param logger: The passed logger object
         :type logger: logging.Logger
         """
@@ -66,7 +66,7 @@ class MLForecaster:
         self.var_model = var_model
         self.sklearn_model = sklearn_model
         self.num_lags = num_lags
-        self.root = root
+        self.emhass_conf = emhass_conf
         self.logger = logger
         self.is_tuned = False
         # A quick data preparation

emhass/machine_learning_regressor.py

@@ -0,0 +1,251 @@
+"""Machine learning regressor module."""
+
+from __future__ import annotations
+
+import copy
+import time
+import warnings
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import (
+    AdaBoostRegressor,
+    GradientBoostingRegressor,
+    RandomForestRegressor,
+)
+from sklearn.linear_model import Lasso, LinearRegression, Ridge
+from sklearn.metrics import r2_score
+from sklearn.model_selection import GridSearchCV, train_test_split
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+if TYPE_CHECKING:
+    import logging
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+REGRESSION_METHODS = {
+    "LinearRegression": {
+        "model": LinearRegression(),
+        "param_grid": {
+            "linearregression__fit_intercept": [True, False],
+            "linearregression__positive": [True, False],
+        },
+    },
+    "RidgeRegression": {
+        "model": Ridge(),
+        "param_grid": {"ridge__alpha": [0.1, 1.0, 10.0]},
+    },
+    "LassoRegression": {
+        "model": Lasso(),
+        "param_grid": {"lasso__alpha": [0.1, 1.0, 10.0]},
+    },
+    "RandomForestRegression": {
+        "model": RandomForestRegressor(),
+        "param_grid": {"randomforestregressor__n_estimators": [50, 100, 200]},
+    },
+    "GradientBoostingRegression": {
+        "model": GradientBoostingRegressor(),
+        "param_grid": {
+            "gradientboostingregressor__n_estimators": [50, 100, 200],
+            "gradientboostingregressor__learning_rate": [0.01, 0.1, 0.2],
+        },
+    },
+    "AdaBoostRegression": {
+        "model": AdaBoostRegressor(),
+        "param_grid": {
+            "adaboostregressor__n_estimators": [50, 100, 200],
+            "adaboostregressor__learning_rate": [0.01, 0.1, 0.2],
+        },
+    },
+}
+
+
+class MLRegressor:
+    r"""A forecaster class using machine learning models.
+
+    This class uses the `sklearn` module and the machine learning models are \
+        from `scikit-learn`.
+
+    It exposes two main methods:
+
+    - `fit`: to train a model with the passed data.
+
+    - `predict`: to obtain a forecast from a pre-trained model.
+
+    """
+
+    def __init__(self: MLRegressor, data: pd.DataFrame, model_type: str, regression_model: str,
+                 features: list, target: str, timestamp: str, logger: logging.Logger) -> None:
+        r"""Define constructor for the forecast class.
+
+        :param data: The data that will be used for train/test
+        :type data: pd.DataFrame
+        :param model_type: A unique name defining this model and useful to identify \
+            for what it will be used for.
+        :type model_type: str
+        :param regression_model: The model that will be used. For now only \
+            this options are possible: `LinearRegression`, `RidgeRegression`, \
+            `LassoRegression`, `RandomForestRegression`, \
+            `GradientBoostingRegression` and `AdaBoostRegression`.
+        :type regression_model: str
+        :param features: A list of features. \
+            Example: [`solar_production`, `degree_days`].
+        :type features: list
+        :param target: The target(to be predicted). \
+            Example: `heating_hours`.
+        :type target: str
+        :param timestamp: If defined, the column key that has to be used of timestamp.
+        :type timestamp: str
+        :param logger: The passed logger object
+        :type logger: logging.Logger
+        """
+        self.data = data
+        self.features = features
+        self.target = target
+        self.timestamp = timestamp
+        self.model_type = model_type
+        self.regression_model = regression_model
+        self.logger = logger
+        self.data = self.data.sort_index()
+        self.data = self.data[~self.data.index.duplicated(keep="first")]
+        self.data_exo = None
+        self.steps = None
+        self.model = None
+        self.grid_search = None
+
+    @staticmethod
+    def add_date_features(data: pd.DataFrame, date_features: list, timestamp: str) -> pd.DataFrame:
+        """Add date features from the input DataFrame timestamp.
+
+        :param data: The input DataFrame
+        :type data: pd.DataFrame
+        :param timestamp: The column containing the timestamp
+        :type timestamp: str
+        :return: The DataFrame with the added features
+        :rtype: pd.DataFrame
+        """
+        df = copy.deepcopy(data)  # noqa: PD901
+        df[timestamp] = pd.to_datetime(df["timestamp"])
+        if "year" in date_features:
+            df["year"] = [i.year for i in df["timestamp"]]
+        if "month" in date_features:
+            df["month"] = [i.month for i in df["timestamp"]]
+        if "day_of_week" in date_features:
+            df["day_of_week"] = [i.dayofweek for i in df["timestamp"]]
+        if "day_of_year" in date_features:
+            df["day_of_year"] = [i.dayofyear for i in df["timestamp"]]
+        if "day" in date_features:
+            df["day"] = [i.day for i in df["timestamp"]]
+        if "hour" in date_features:
+            df["hour"] = [i.day for i in df["timestamp"]]
+        return df
+
+    def get_regression_model(self: MLRegressor) -> tuple[str, str]:
+        r"""
+        Get the base model and parameter grid for the specified regression model.
+        Returns a tuple containing the base model and parameter grid corresponding to \
+            the specified regression model.
+
+        :param self: The instance of the MLRegressor class.
+        :type self: MLRegressor
+        :return: A tuple containing the base model and parameter grid.
+        :rtype: tuple[str, str]
+        """
+        if self.regression_model == "LinearRegression":
+            base_model = REGRESSION_METHODS["LinearRegression"]["model"]
+            param_grid = REGRESSION_METHODS["LinearRegression"]["param_grid"]
+        elif self.regression_model == "RidgeRegression":
+            base_model = REGRESSION_METHODS["RidgeRegression"]["model"]
+            param_grid = REGRESSION_METHODS["RidgeRegression"]["param_grid"]
+        elif self.regression_model == "LassoRegression":
+            base_model = REGRESSION_METHODS["LassoRegression"]["model"]
+            param_grid = REGRESSION_METHODS["LassoRegression"]["param_grid"]
+        elif self.regression_model == "RandomForestRegression":
+            base_model = REGRESSION_METHODS["RandomForestRegression"]["model"]
+            param_grid = REGRESSION_METHODS["RandomForestRegression"]["param_grid"]
+        elif self.regression_model == "GradientBoostingRegression":
+            base_model = REGRESSION_METHODS["GradientBoostingRegression"]["model"]
+            param_grid = REGRESSION_METHODS["GradientBoostingRegression"]["param_grid"]
+        elif self.regression_model == "AdaBoostRegression":
+            base_model = REGRESSION_METHODS["AdaBoostRegression"]["model"]
+            param_grid = REGRESSION_METHODS["AdaBoostRegression"]["param_grid"]
+        else:
+            self.logger.error(
+                "Passed model %s is not valid",
+                self.regression_model,
+            )
+            return None
+        return base_model, param_grid
+
+    def fit(self: MLRegressor, date_features: list | None = None) -> None:
+        r"""Fit the model using the provided data.
+
+        :param date_features: A list of 'date_features' to take into account when \
+            fitting the model.
+        :type data: list
+        """
+        self.logger.info("Performing a MLRegressor fit for %s", self.model_type)
+        self.data_exo = pd.DataFrame(self.data)
+        self.data_exo[self.features] = self.data[self.features]
+        self.data_exo[self.target] = self.data[self.target]
+        keep_columns = []
+        keep_columns.extend(self.features)
+        if self.timestamp is not None:
+            keep_columns.append(self.timestamp)
+        keep_columns.append(self.target)
+        self.data_exo = self.data_exo[self.data_exo.columns.intersection(keep_columns)]
+        self.data_exo = self.data_exo.reset_index(drop=True)
+        if date_features is not None:
+            if self.timestamp is not None:
+                self.data_exo = MLRegressor.add_date_features(
+                    self.data_exo,
+                    date_features,
+                    self.timestamp,
+                )
+            else:
+                self.logger.error(
+                    "If no timestamp provided, you can't use date_features, going \
+                    further without date_features.",
+                )
+        y = self.data_exo[self.target]
+        self.data_exo = self.data_exo.drop(self.target, axis=1)
+        if self.timestamp is not None:
+            self.data_exo = self.data_exo.drop(self.timestamp, axis=1)
+        X = self.data_exo 
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        self.steps = len(X_test)
+        base_model, param_grid = self.get_regression_model()
+        self.model = make_pipeline(StandardScaler(), base_model)
+        # Create a grid search object
+        self.grid_search = GridSearchCV(self.model, param_grid, cv=5, scoring="neg_mean_squared_error",
+                                        refit=True, verbose=0, n_jobs=-1)
+        # Fit the grid search object to the data
+        self.logger.info("Training a %s model", self.regression_model)
+        start_time = time.time()
+        self.grid_search.fit(X_train.values, y_train.values)
+        self.logger.info("Elapsed time for model fit: %s", time.time() - start_time)
+        self.model = self.grid_search.best_estimator_
+        # Make predictions
+        predictions = self.model.predict(X_test.values)
+        predictions = pd.Series(predictions, index=X_test.index)
+        pred_metric = r2_score(y_test, predictions)
+        self.logger.info(
+            "Prediction R2 score of fitted model on test data: %s",
+            pred_metric,
+        )
+
+    def predict(self: MLRegressor, new_values: list) -> np.ndarray:
+        """Predict a new value.
+
+        :param new_values: The new values for the features \
+            (in the same order as the features list). \
+            Example: [2.24, 5.68].
+        :type new_values: list
+        :return: The np.ndarray containing the predicted value.
+        :rtype: np.ndarray
+        """
+        self.logger.info("Performing a prediction for %s", self.model_type)
+        new_values = np.array([new_values])
+        return self.model.predict(new_values)

emhass/optimization.py

@@ -31,7 +31,7 @@ class Optimization:
 
     def __init__(self, retrieve_hass_conf: dict, optim_conf: dict, plant_conf: dict, 
                  var_load_cost: str, var_prod_price: str, 
-                 costfun: str, base_path: str, logger: logging.Logger, 
+                 costfun: str, emhass_conf: dict, logger: logging.Logger, 
                  opt_time_delta: Optional[int] = 24) -> None:
         r"""
         Define constructor for Optimization class.
@@ -50,8 +50,8 @@ class Optimization:
         :type var_prod_price: str
         :param costfun: The type of cost function to use for optimization problem
         :type costfun: str
-        :param base_path: The path to the yaml configuration file
-        :type base_path: str
+        :param emhass_conf: Dictionary containing the needed emhass paths
+        :type emhass_conf: dict
         :param logger: The passed logger object
         :type logger: logging object
         :param opt_time_delta: The number of hours to optimize. If days_list has \
@@ -71,6 +71,7 @@ class Optimization:
         self.var_load = self.retrieve_hass_conf['var_load']
         self.var_load_new = self.var_load+'_positive'
         self.costfun = costfun
+        # self.emhass_conf = emhass_conf
         self.logger = logger
         self.var_load_cost = var_load_cost
         self.var_prod_price = var_prod_price