[quantile regression project] refactor simulations. add transformed coordinate...

[quantile regression project] refactor simulations. add transformed coordinate to the quantile functions

extreme_fit/function/abstract_function.py

+import numpy as np
+
 from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
 
 
@@ -6,3 +8,5 @@ class AbstractFunction(object):
     def __init__(self, coordinates: AbstractCoordinates):
         self.coordinates = coordinates
 
+    def transform(self, coordinate: np.ndarray) -> np.ndarray:
+        return self.coordinates.transformation.transform_array(coordinate)

extreme_fit/function/abstract_quantile_function.py

@@ -10,7 +10,11 @@ from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoo
 
 class AbstractQuantileFunction(AbstractFunction):
 
-    def get_quantile(self, coordinate: np.ndarray) -> float:
+    def get_quantile(self, coordinate: np.ndarray, is_transformed: bool = True) -> float:
+        transformed_coordinate = coordinate if is_transformed else self.transform(coordinate)
+        return self._get_quantile(transformed_coordinate)
+
+    def _get_quantile(self, coordinate: np.ndarray):
         raise NotImplementedError
 
     def visualize(self, show=True):
@@ -43,7 +47,7 @@ class QuantileFunctionFromParamFunction(AbstractQuantileFunction):
         super().__init__(coordinates)
         self.param_function = param_function
 
-    def get_quantile(self, coordinate: np.ndarray) -> float:
+    def _get_quantile(self, coordinate: np.ndarray) -> float:
         return self.param_function.get_param_value(coordinate)
 
 
@@ -54,6 +58,6 @@ class QuantileFunctionFromMarginFunction(AbstractQuantileFunction):
         self.margin_function = margin_function
         self.quantile = quantile
 
-    def get_quantile(self, coordinate: np.ndarray) -> float:
+    def _get_quantile(self, coordinate: np.ndarray) -> float:
         gev_params = self.margin_function.get_gev_params(coordinate)
         return gev_params.quantile(self.quantile)

extreme_fit/function/margin_function/independent_margin_function.py

@@ -32,8 +32,7 @@ class IndependentMarginFunction(AbstractMarginFunction):
             gev_params[gev_param_name] = param_function.get_param_value(transformed_coordinate)
         return GevParams.from_dict(gev_params)
 
-    def transform(self, coordinate: np.ndarray) -> np.ndarray:
-        return self.coordinates.transformation.transform_array(coordinate)
+
 
 
 

projects/quantile_regression_vs_evt/AbstractSimulation.py

@@ -16,16 +16,12 @@ from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoo
 from spatio_temporal_dataset.coordinates.temporal_coordinates.generated_temporal_coordinates import \
     ConsecutiveTemporalCoordinates
 from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.abstract_transformation import \
-    CenteredScaledNormalization, IdentityTransformation
+    CenteredScaledNormalization
 from spatio_temporal_dataset.dataset.abstract_dataset import AbstractDataset
 from spatio_temporal_dataset.spatio_temporal_observations.abstract_spatio_temporal_observations import \
     AbstractSpatioTemporalObservations
 
 
-class Coordinates(object):
-    pass
-
-
 class AbstractSimulation(object):
 
     def __init__(self, nb_time_series, quantile, time_series_lengths=None, multiprocessing=False,
@@ -41,31 +37,31 @@ class AbstractSimulation(object):
         raise NotImplementedError
 
     @cached_property
-    def time_serie_length_to_observation_list(self) -> Dict[int, List[AbstractSpatioTemporalObservations]]:
+    def time_series_length_to_observation_list(self) -> Dict[int, List[AbstractSpatioTemporalObservations]]:
         d = OrderedDict()
         for length in self.time_series_lengths:
             d[length] = self.generate_all_observation(self.nb_time_series, length)
         return d
 
     @cached_property
-    def time_serie_length_to_coordinates(self) -> Dict[int, AbstractCoordinates]:
+    def time_series_length_to_coordinates(self) -> Dict[int, AbstractCoordinates]:
         d = OrderedDict()
         for length in self.time_series_lengths:
-            d[length] = ConsecutiveTemporalCoordinates.from_nb_temporal_steps(length,
-                                                                              transformation_class=self.transformation_class)
+            d[length] = ConsecutiveTemporalCoordinates.\
+                from_nb_temporal_steps(length, transformation_class=self.transformation_class)
         return d
 
     @cached_property
-    def model_class_to_time_serie_length_to_estimator_fitted(self):
+    def model_class_to_time_series_length_to_estimators(self):
         d = OrderedDict()
         for model_class in self.models_classes:
             d_sub = OrderedDict()
-            for time_serie_length, observation_list in self.time_serie_length_to_observation_list.items():
-                coordinates = self.time_serie_length_to_coordinates[time_serie_length]
-                estimators_fitted = []
+            for time_series_length, observation_list in self.time_series_length_to_observation_list.items():
+                coordinates = self.time_series_length_to_coordinates[time_series_length]
+                estimators = []
                 for observations in observation_list:
-                    estimators_fitted.append(self.get_fitted_quantile_estimator(model_class, observations, coordinates))
-                d_sub[time_serie_length] = estimators_fitted
+                    estimators.append(self.get_fitted_quantile_estimator(model_class, observations, coordinates))
+                d_sub[time_series_length] = estimators
             d[model_class] = d_sub
         return d
 
@@ -83,7 +79,7 @@ class AbstractSimulation(object):
     @cached_property
     def model_class_to_error_last_year_quantile(self):
         d = OrderedDict()
-        for model_class, d_sub in self.model_class_to_time_serie_length_to_estimator_fitted.items():
+        for model_class, d_sub in self.model_class_to_time_series_length_to_estimators.items():
             length_to_error_values = OrderedDict()
             for length, estimators_fitted in d_sub.items():
                 errors = self.compute_errors(length, estimators_fitted)

projects/quantile_regression_vs_evt/GevSimulation.py

@@ -23,7 +23,7 @@ class GevSimulation(AbstractSimulation):
     def time_series_lengths_to_margin_model(self) -> Dict[int, AbstractMarginModel]:
         d = OrderedDict()
         for length in self.time_series_lengths:
-            coordinates = self.time_serie_length_to_coordinates[length]
+            coordinates = self.time_series_length_to_coordinates[length]
             d[length] = self.create_model(coordinates)
         return d
 
@@ -31,13 +31,13 @@ class GevSimulation(AbstractSimulation):
         raise NotImplementedError
 
     def generate_all_observation(self, nb_time_series, length) -> List[AbstractSpatioTemporalObservations]:
-        coordinates = self.time_serie_length_to_coordinates[length]
+        coordinates = self.time_series_length_to_coordinates[length]
         margin_model = self.time_series_lengths_to_margin_model[length]
         return [MarginAnnualMaxima.from_sampling(nb_obs=1, coordinates=coordinates, margin_model=margin_model)
                 for _ in range(nb_time_series)]
 
     def compute_errors(self, length: int, estimators: List[AbstractQuantileEstimator]):
-        coordinates = self.time_serie_length_to_coordinates[length]
+        coordinates = self.time_series_length_to_coordinates[length]
         last_coordinate = coordinates.coordinates_values()[-1]
         # Compute true value
         margin_model = self.time_series_lengths_to_margin_model[length]