Fix predict

fedot_ind/core/models/ts_forecasting/markov_ar.py

@@ -2,6 +2,8 @@
 
 import numpy as np
 import pandas as pd
+from scipy import stats
+from scipy.special import boxcox, inv_boxcox
 import statsmodels.api as sm
 from statsmodels.tsa.ar_model import AutoReg
 from statsmodels.tsa.regime_switching.markov_autoregression import MarkovAutoregression
@@ -12,6 +14,7 @@
 from fedot.core.operations.evaluation.operation_implementations.implementation_interfaces import ModelImplementation
 from fedot.core.operations.operation_parameters import OperationParameters
 from fedot.core.repository.dataset_types import DataTypesEnum
+from fedot.utilities.ts_gapfilling import SimpleGapFiller
 from fedot_ind.core.models.ts_forecasting.markov_extension import MSARExtension
 
 from sklearn.preprocessing import StandardScaler
@@ -23,24 +26,26 @@ def __init__(self, params: OperationParameters):
         self.autoreg = None
         self.actual_ts_len = None
         self.scaler = StandardScaler()
+        self.lambda_param = None
+        self.scope = None
 
     def fit(self, input_data):
         """ Class fit ar model on data
 
         :param input_data: data with features, target and ids to process
         """
 
-        source_ts = pd.DataFrame(input_data.features)
-        # source_ts = pd.DataFrame(self.scaler.fit_transform(input_data.features.reshape(-1, 1)))
+        # source_ts = pd.DataFrame(input_data.features)
+        source_ts = pd.DataFrame(self.scaler.fit_transform(input_data.features.reshape(-1, 1)))
 
         self.actual_ts_len = len(source_ts)
 
         self.autoreg = MarkovAutoregression(source_ts, 
                         k_regimes=2, 
                         order=4,
-                        switching_variance=True).fit()
+                        switching_variance=False).fit()
 
-        self.actual_ts_len = input_data.idx.shape[0]
+        # self.actual_ts_len = input_data.idx.shape[0]
 
         return self.autoreg
 
@@ -50,20 +55,25 @@ def predict(self, input_data):
         :param input_data: data with features, target and ids to process
         :return output_data: output data with smoothed time series
         """
-        input_data = copy(input_data)
+        # input_data = copy(input_data)
         parameters = input_data.task.task_params
         forecast_length = parameters.forecast_length
 
         # in case in(out) sample forecasting
         self.handle_new_data(input_data)
         start_id = self.actual_ts_len
         end_id = start_id + forecast_length - 1
-        # predicted = self.autoreg.predict(start=start_id, end=end_id)
+        predicted = self.autoreg.predict(start=start_id, end=end_id)
+        # predicted = []
+        # for t in range(start_id, end_id):
+        #     self.autoreg = self.autoreg(input_data[start_id:t])
+        #     predicted = MSARExtension(self.autoreg).predict_out_of_sample()
 
-        predicted = MSARExtension(self.autoreg).predict_out_of_sample()
+        predict = self.scaler.inverse_transform(np.array([predicted]).ravel().reshape(1, -1))
+        # predict = np.array(predicted).reshape(1, -1)
+        # new_idx = np.arange(start_id, end_id + 1)
 
-        # predict = np.array(self.scaler.inverse_transform(predicted).ravel())[0].reshape(1, -1)
-        predict = np.array(predicted).reshape(1, -1)
+        # input_data.idx = new_idx
 
         output_data = self._convert_to_output(input_data,
                                               predict=predict,
@@ -96,6 +106,38 @@ def predict_for_fit(self, input_data: InputData) -> OutputData:
                                               data_type=DataTypesEnum.table)
         return output_data
 
+    # def predict_for_fit(self, input_data: InputData) -> OutputData:
+    #     parameters = input_data.task.task_params
+    #     forecast_length = parameters.forecast_length
+    #     idx = input_data.idx
+    #     target = input_data.target
+
+    #     fitted_values = self.autoreg.predict(start=idx[0], end=idx[-1])
+    #     diff = int(self.actual_ts_len) - len(fitted_values)
+    #     # If first elements skipped
+    #     if diff != 0:
+    #         # Fill nans with first values
+    #         first_element = fitted_values[0]
+    #         first_elements = [first_element] * diff
+    #         first_elements.extend(list(fitted_values))
+
+    #         fitted_values = np.array(first_elements)
+
+    #     _, predict = ts_to_table(idx=idx,
+    #                              time_series=fitted_values,
+    #                              window_size=forecast_length)
+
+    #     new_idx, target_columns = ts_to_table(idx=idx,
+    #                                           time_series=target,
+    #                                           window_size=forecast_length)
+
+    #     input_data.idx = new_idx
+    #     input_data.target = target_columns
+    #     output_data = self._convert_to_output(input_data,
+    #                                           predict=predict,
+    #                                           data_type=DataTypesEnum.table)
+    #     return output_data
+
     def handle_new_data(self, input_data: InputData):
         """
         Method to update x samples inside a model (used when we want to use old model to a new data)