[refactor] refactor test_quantile_estimator.py. Quantile estimators works for...

[refactor] refactor test_quantile_estimator.py. Quantile estimators works for any temporal coordinates.

extreme_fit/estimator/quantile_estimator/abstract_quantile_estimator.py

@@ -10,6 +10,8 @@ from extreme_fit.function.abstract_quantile_function import AbstractQuantileFunc
 from extreme_fit.function.margin_function.abstract_margin_function import AbstractMarginFunction
 from extreme_fit.function.param_function.linear_coef import LinearCoef
 from extreme_fit.function.param_function.param_function import LinearParamFunction
+from extreme_fit.model.margin_model.linear_margin_model.abstract_temporal_linear_margin_model import \
+    AbstractTemporalLinearMarginModel
 from extreme_fit.model.margin_model.linear_margin_model.linear_margin_model import LinearMarginModel
 from extreme_fit.model.quantile_model.quantile_regression_model import AbstractQuantileRegressionModel
 from extreme_fit.model.result_from_model_fit.abstract_result_from_model_fit import AbstractResultFromModelFit
@@ -31,7 +33,7 @@ class AbstractQuantileEstimator(AbstractEstimator, ABC):
 
 class QuantileEstimatorFromMargin(LinearMarginEstimator, AbstractQuantileEstimator):
 
-    def __init__(self, dataset: AbstractDataset, margin_model: LinearMarginModel, quantile):
+    def __init__(self, dataset: AbstractDataset, margin_model: AbstractTemporalLinearMarginModel, quantile):
         super().__init__(dataset=dataset, quantile=quantile, margin_model=margin_model)
 
     @cached_property
@@ -53,8 +55,10 @@ class QuantileRegressionEstimator(AbstractQuantileEstimator):
     def function_from_fit(self) -> AbstractQuantileFunction:
         result_from_model_fit = self.result_from_model_fit  # type: ResultFromQuantreg
         coefs = result_from_model_fit.coefficients
-        dims = list(np.arange(len(coefs)) - 1)
-        linear_coef = LinearCoef('quantile', idx_to_coef=dict(zip(dims, coefs)))
+        nb_coefs = len(coefs)
+        dims = list(range(nb_coefs-1))
+        idx_to_coef = dict(zip([-1] + dims, coefs))
+        linear_coef = LinearCoef(idx_to_coef=idx_to_coef)
         param_function = LinearParamFunction(dims=dims, coordinates=self.dataset.coordinates.coordinates_values(),
                                              linear_coef=linear_coef)
         return QuantileFunctionFromParamFunction(coordinates=self.dataset.coordinates,

extreme_fit/model/quantile_model/quantile_regression_model.py

@@ -4,6 +4,7 @@ from rpy2 import robjects
 from extreme_fit.model.abstract_model import AbstractModel
 from extreme_fit.model.result_from_model_fit.result_from_quantilreg import ResultFromQuantreg
 from extreme_fit.model.utils import r, safe_run_r_estimator, get_coord_df
+from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
 from spatio_temporal_dataset.dataset.abstract_dataset import AbstractDataset
 
 
@@ -47,8 +48,10 @@ class ConstantQuantileRegressionModel(AbstractQuantileRegressionModel):
         return '1'
 
 
-class AllCoordinatesQuantileRegressionModel(AbstractQuantileRegressionModel):
+class TemporalCoordinatesQuantileRegressionModel(AbstractQuantileRegressionModel):
 
     @property
     def formula_str(self):
-        return  '+'.join(self.dataset.coordinates.coordinates_names[-1:])
+        assert self.dataset.coordinates.has_temporal_coordinates \
+               and not self.dataset.coordinates.has_spatial_coordinates
+        return AbstractCoordinates.COORDINATE_T

extreme_fit/model/result_from_model_fit/result_from_quantilreg.py

+import numpy as np
 from cached_property import cached_property
 
 from extreme_fit.function.param_function.param_function import LinearParamFunction
@@ -8,4 +9,4 @@ class ResultFromQuantreg(AbstractResultFromModelFit):
 
     @property
     def coefficients(self):
-        return self.name_to_value['coefficients']
+        return np.array(self.name_to_value['coefficients'])

test/test_extreme_fit/test_estimator/test_quantile_estimator.py

@@ -2,29 +2,23 @@ import unittest
 
 from extreme_fit.estimator.quantile_estimator.abstract_quantile_estimator import QuantileEstimatorFromMargin, \
     QuantileRegressionEstimator
+from extreme_fit.model.margin_model.linear_margin_model.temporal_linear_margin_models import StationaryTemporalModel
 from spatio_temporal_dataset.dataset.simulation_dataset import MarginDataset
 from test.test_utils import load_test_1D_and_2D_spatial_coordinates, load_test_spatiotemporal_coordinates, \
-    load_smooth_margin_models, load_smooth_quantile_model_classes
+    load_smooth_margin_models, load_smooth_quantile_model_classes, load_test_temporal_coordinates
 
 
 class TestQuantileEstimator(unittest.TestCase):
     DISPLAY = False
 
-    def test_smooth_margin_estimator_spatial(self):
+    def test_quantile_estimator_temporal(self):
         self.nb_points = 20
         self.nb_obs = 1
-        self.coordinates = load_test_1D_and_2D_spatial_coordinates(nb_points=self.nb_points)[:1]
+        self.coordinates = load_test_temporal_coordinates(nb_steps=self.nb_points)
 
-    def test_smooth_margin_estimator_spatio_temporal(self):
-        self.nb_points = 2
-        self.nb_steps = 2
-        self.nb_obs = 1
-        self.coordinates = load_test_spatiotemporal_coordinates(nb_steps=self.nb_steps, nb_points=self.nb_points)
-
-    def tearDown(self) -> None:
         quantile = 0.5
         for coordinates in self.coordinates:
-            constant_margin_model = load_smooth_margin_models(coordinates=coordinates)[0]
+            constant_margin_model = StationaryTemporalModel(coordinates)
             dataset = MarginDataset.from_sampling(nb_obs=self.nb_obs,
                                                   margin_model=constant_margin_model,
                                                   coordinates=coordinates)
@@ -32,7 +26,7 @@ class TestQuantileEstimator(unittest.TestCase):
             quantile_estimators = [
                 QuantileEstimatorFromMargin(dataset, constant_margin_model, quantile),
             ]
-            for quantile_model_class in load_smooth_quantile_model_classes()[:1]:
+            for quantile_model_class in load_smooth_quantile_model_classes()[:]:
                 quantile_estimator = QuantileRegressionEstimator(dataset, quantile, quantile_model_class)
                 quantile_estimators.append(quantile_estimator)
 

test/test_utils.py

@@ -18,7 +18,7 @@ from extreme_fit.model.max_stable_model.max_stable_models import Smith, BrownRes
 from extreme_data.meteo_france_data.scm_models_data.safran.safran import SafranSnowfall, Safran, SafranRainfall, \
     SafranTemperature, SafranPrecipitation
 from extreme_fit.model.quantile_model.quantile_regression_model import ConstantQuantileRegressionModel, \
-    AllCoordinatesQuantileRegressionModel
+    TemporalCoordinatesQuantileRegressionModel
 from spatio_temporal_dataset.coordinates.spatial_coordinates.abstract_spatial_coordinates import \
     AbstractSpatialCoordinates
 from spatio_temporal_dataset.coordinates.spatial_coordinates.alps_station_3D_coordinates import \
@@ -43,7 +43,7 @@ TEST_3D_SPATIAL_COORDINATES = [AlpsStation3DCoordinatesWithAnisotropy]
 TEST_TEMPORAL_COORDINATES = [ConsecutiveTemporalCoordinates]
 TEST_SPATIO_TEMPORAL_COORDINATES = [UniformSpatioTemporalCoordinates, LinSpaceSpatial2DSpatioTemporalCoordinates]
 TEST_MARGIN_TYPES = [ConstantMarginModel, LinearAllParametersAllDimsMarginModel][:]
-TEST_QUANTILES_TYPES = [ConstantQuantileRegressionModel, AllCoordinatesQuantileRegressionModel][:]
+TEST_QUANTILES_TYPES = [ConstantQuantileRegressionModel, TemporalCoordinatesQuantileRegressionModel][:]
 TEST_NON_STATIONARY_TEMPORAL_MARGIN_TYPES = [NonStationaryLocationTemporalModel, NonStationaryScaleTemporalModel,
                                              NonStationaryShapeTemporalModel]
 TEST_MAX_STABLE_ESTIMATOR = [MaxStableEstimator]