[COORDINATES] refactor coordinates. add abstract spatial, temporal, and spatio_temporal

experiment/fit_diagnosis/split_curve_example.py

-from typing import Union
-
-from experiment.fit_diagnosis.split_curve import SplitCurve
-from extreme_estimator.estimator.full_estimator import AbstractFullEstimator
-from extreme_estimator.estimator.margin_estimator import AbstractMarginEstimator, ConstantMarginEstimator
-from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
-
-import random
-
 from experiment.fit_diagnosis.split_curve import SplitCurve
 from extreme_estimator.estimator.full_estimator import FullEstimatorInASingleStepWithSmoothMargin
-from extreme_estimator.estimator.margin_estimator import SmoothMarginEstimator
 from extreme_estimator.extreme_models.margin_model.smooth_margin_model import ConstantMarginModel, \
     LinearAllParametersAllDimsMarginModel
 from extreme_estimator.extreme_models.max_stable_model.max_stable_models import Smith
 from extreme_estimator.gev_params import GevParams
-from spatio_temporal_dataset.coordinates.unidimensional_coordinates.coordinates_1D import LinSpaceCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import LinSpaceSpatialCoordinates
 from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
 
 
@@ -24,7 +14,7 @@ class SplitCurveExample(SplitCurve):
         super().__init__(nb_fit)
         self.nb_points = 50
         self.nb_obs = 60
-        self.coordinates = LinSpaceCoordinates.from_nb_points(nb_points=self.nb_points, train_split_ratio=0.8)
+        self.coordinates = LinSpaceSpatialCoordinates.from_nb_points(nb_points=self.nb_points, train_split_ratio=0.8)
         # MarginModel Linear with respect to the shape (from 0.01 to 0.02)
         params_sample = {
             (GevParams.GEV_LOC, 0): 10,

experiment/regression_margin/regression_margin.py

-import random
-
 import numpy as np
 
 from extreme_estimator.estimator.full_estimator import FullEstimatorInASingleStepWithSmoothMargin
 from extreme_estimator.extreme_models.margin_model.margin_function.linear_margin_function import LinearMarginFunction
-from extreme_estimator.extreme_models.margin_model.smooth_margin_model import LinearShapeDim1MarginModel, \
-    LinearAllParametersAllDimsMarginModel, LinearScaleDim1MarginModel, ConstantMarginModel
+from extreme_estimator.extreme_models.margin_model.smooth_margin_model import LinearAllParametersAllDimsMarginModel, \
+    ConstantMarginModel
 from extreme_estimator.extreme_models.max_stable_model.max_stable_models import Smith
 from extreme_estimator.gev_params import GevParams
-from spatio_temporal_dataset.coordinates.unidimensional_coordinates.coordinates_1D import LinSpaceCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import LinSpaceSpatialCoordinates
 import matplotlib.pyplot as plt
 
 from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
@@ -18,7 +16,7 @@ nb_obs = 60
 nb_estimator = 2
 show = False
 
-coordinates = LinSpaceCoordinates.from_nb_points(nb_points=nb_points)
+coordinates = LinSpaceSpatialCoordinates.from_nb_points(nb_points=nb_points)
 
 ########## GENERATING THE DATA #####################
 

experiment/regression_margin/visualization_margin_model.py

@@ -3,8 +3,8 @@ import unittest
 from extreme_estimator.gev_params import GevParams
 from extreme_estimator.extreme_models.margin_model.smooth_margin_model import LinearShapeDim1MarginModel, \
     LinearAllParametersAllDimsMarginModel
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleCoordinates
-from spatio_temporal_dataset.coordinates.unidimensional_coordinates.coordinates_1D import LinSpaceCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import LinSpaceSpatialCoordinates
 
 
 class VisualizationMarginModel(unittest.TestCase):
@@ -14,14 +14,14 @@ class VisualizationMarginModel(unittest.TestCase):
 
     @classmethod
     def example_visualization_2D(cls):
-        spatial_coordinates = CircleCoordinates.from_nb_points(nb_points=cls.nb_points)
+        spatial_coordinates = CircleSpatialCoordinates.from_nb_points(nb_points=cls.nb_points)
         margin_model = cls.margin_model(coordinates=spatial_coordinates)
         if cls.DISPLAY:
             margin_model.margin_function_sample.visualize()
 
     @classmethod
     def example_visualization_1D(cls):
-        coordinates = LinSpaceCoordinates.from_nb_points(nb_points=cls.nb_points)
+        coordinates = LinSpaceSpatialCoordinates.from_nb_points(nb_points=cls.nb_points)
         margin_model = cls.margin_model(coordinates=coordinates, params_sample={(GevParams.GEV_SHAPE, 1): 0.02})
         if cls.DISPLAY:
             margin_model.margin_function_sample.visualize()

experiment/robustness_plot/estimation_robustness/max_stable_process_plot.py

@@ -5,7 +5,7 @@ from experiment.robustness_plot.display_item import DisplayItem
 from experiment.robustness_plot.multiple_plot import MultiplePlot
 from experiment.robustness_plot.single_plot import SinglePlot
 from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates
 from spatio_temporal_dataset.dataset.simulation_dataset import MaxStableDataset
 
 
@@ -23,7 +23,7 @@ class CoordinateDisplayItem(DisplayItem):
 
 class MaxStableProcessPlot(object):
     MaxStableModelItem = MaxStableDisplayItem('max_stable_model', Smith)
-    CoordinateClassItem = CoordinateDisplayItem('coordinate_class', CircleCoordinates)
+    CoordinateClassItem = CoordinateDisplayItem('coordinate_class', CircleSpatialCoordinates)
     NbStationItem = DisplayItem('Number of stations', 50)
     NbObservationItem = DisplayItem('nb_obs', 60)
 

experiment/robustness_plot/estimation_robustness/spatial_robustness/alps_msp_robustness.py

@@ -4,8 +4,8 @@ from experiment.robustness_plot.estimation_robustness.max_stable_process_plot im
 from experiment.robustness_plot.single_plot import SinglePlot
 from spatio_temporal_dataset.coordinates.spatial_coordinates.alps_station_2D_coordinates import \
     AlpsStation2DCoordinatesBetweenZeroAndOne, AlpsStationCoordinatesBetweenZeroAndTwo
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleCoordinates, \
-    CircleCoordinatesRadius2
+from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates, \
+    CircleSpatialCoordinatesRadius2
 
 
 # def single_spatial_robustness_alps():
@@ -49,8 +49,8 @@ def multiple_spatial_robustness_alps():
         MaxStableProcessPlot.NbStationItem.name: nb_stations,
         MaxStableProcessPlot.NbObservationItem.name: nb_observation,
         MaxStableProcessPlot.MaxStableModelItem.name: msp_models,
-        MaxStableProcessPlot.CoordinateClassItem.name: [CircleCoordinates,
-                                                        CircleCoordinatesRadius2,
+        MaxStableProcessPlot.CoordinateClassItem.name: [CircleSpatialCoordinates,
+                                                        CircleSpatialCoordinatesRadius2,
                                                         AlpsStation2DCoordinatesBetweenZeroAndOne,
                                                         AlpsStationCoordinatesBetweenZeroAndTwo][:],
     })

experiment/robustness_plot/estimation_robustness/unidimensional_robustness/unidimensional_robustness.py

@@ -4,8 +4,8 @@ from experiment.robustness_plot.estimation_robustness.max_stable_process_plot im
 from experiment.robustness_plot.single_plot import SinglePlot
 from spatio_temporal_dataset.coordinates.spatial_coordinates.alps_station_2D_coordinates import \
     AlpsStation2DCoordinatesBetweenZeroAndOne, AlpsStationCoordinatesBetweenZeroAndTwo
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleCoordinates, \
-    CircleCoordinatesRadius2
+from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates, \
+    CircleSpatialCoordinatesRadius2
 
 
 # def single_spatial_robustness_alps():
@@ -49,8 +49,8 @@ def multiple_unidimensional_robustness():
         MaxStableProcessPlot.NbStationItem.name: nb_stations,
         MaxStableProcessPlot.NbObservationItem.name: nb_observation,
         MaxStableProcessPlot.MaxStableModelItem.name: msp_models,
-        MaxStableProcessPlot.CoordinateClassItem.name: [CircleCoordinates,
-                                                        CircleCoordinatesRadius2,
+        MaxStableProcessPlot.CoordinateClassItem.name: [CircleSpatialCoordinates,
+                                                        CircleSpatialCoordinatesRadius2,
                                                         AlpsStation2DCoordinatesBetweenZeroAndOne,
                                                         AlpsStationCoordinatesBetweenZeroAndTwo][:],
     })

extreme_estimator/extreme_models/max_stable_model/abstract_max_stable_model.py

@@ -84,6 +84,7 @@ class AbstractMaxStableModel(AbstractModel):
         """
         Return an numpy of maxima. With rows being the stations and columns being the years of maxima
         """
+
         maxima_frech = np.array(
             r.rmaxstab(nb_obs, coordinates_values, *list(self.cov_mod_param.values()), **self.params_sample))
         return np.transpose(maxima_frech)

spatio_temporal_dataset/coordinates/abstract_coordinates.py

@@ -23,11 +23,11 @@ class AbstractCoordinates(object):
     SPATIAL_SPLIT = 'spatial_split'
     # Temporal columns
     COORDINATE_T = 'coord_t'
-    TEMPORAL_SPLIT = 'coord_temporal_split'
+    TEMPORAL_SPLIT = 'temporal_split'
+    # Coordinates columns
     COORDINATES_NAMES = COORDINATE_SPATIAL_NAMES + [COORDINATE_T]
 
-    def __init__(self, df_coord: pd.DataFrame, s_split_spatial: pd.Series = None, s_split_temporal: pd.Series = None,
-                 slicer_class: type = SpatialSlicer):
+    def __init__(self, df_coord: pd.DataFrame, slicer_class: type, s_split_spatial: pd.Series = None, s_split_temporal: pd.Series = None):
         self.df_all_coordinates = df_coord  # type: pd.DataFrame
         self.s_split_spatial = s_split_spatial  # type: pd.Series
         self.s_split_temporal = s_split_temporal  # type: pd.Series
@@ -38,7 +38,7 @@ class AbstractCoordinates(object):
     # ClassMethod constructor
 
     @classmethod
-    def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None, slicer_class: type = SpatialSlicer):
+    def from_df_and_slicer(cls, df: pd.DataFrame, slicer_class: type, train_split_ratio: float = None):
         """
         train_split_ratio is shared between the spatial part of the data, and the temporal part
         """
@@ -46,16 +46,19 @@ class AbstractCoordinates(object):
         assert len(set(df.index)) == len(df)
 
         # Create a spatial split
-        s_split_spatial = s_split_from_df(df, cls.COORDINATE_X, cls.SPATIAL_SPLIT, train_split_ratio, concat=False)
+        if slicer_class in [SpatialSlicer, SpatioTemporalSlicer]:
+            s_split_spatial = s_split_from_df(df, cls.COORDINATE_X, cls.SPATIAL_SPLIT, train_split_ratio, concat=False)
+        else:
+            s_split_spatial = None
 
         # Create a temporal split
-        if slicer_class is SpatioTemporalSlicer:
+        if slicer_class in [TemporalSlicer, SpatioTemporalSlicer]:
             s_split_temporal = s_split_from_df(df, cls.COORDINATE_T, cls.TEMPORAL_SPLIT, train_split_ratio, concat=True)
         else:
             s_split_temporal = None
 
-        return cls(df_coord=df, s_split_spatial=s_split_spatial, s_split_temporal=s_split_temporal,
-                   slicer_class=slicer_class)
+        return cls(df_coord=df, slicer_class=slicer_class,
+                   s_split_spatial=s_split_spatial, s_split_temporal=s_split_temporal)
 
     @classmethod
     def from_csv(cls, csv_path: str = None):

spatio_temporal_dataset/coordinates/spatial_coordinates/abstract_spatial_coordinates.py

+import pandas as pd
+
+from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+from spatio_temporal_dataset.slicer.spatial_slicer import SpatialSlicer
+
+
+class AbstractSpatialCoordinates(AbstractCoordinates):
+
+    @classmethod
+    def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None):
+        assert cls.COORDINATE_X in df.columns
+        assert cls.COORDINATE_T not in df.columns
+        return super().from_df_and_slicer(df, SpatialSlicer, train_split_ratio)

spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_2D_coordinates.py

 from spatio_temporal_dataset.coordinates.spatial_coordinates.alps_station_3D_coordinates import AlpsStation3DCoordinates
-from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation_2D import \
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.transformation_2D import \
     BetweenZeroAndOne2DNormalization
 from spatio_temporal_dataset.coordinates.transformed_coordinates.transformed_coordinates import TransformedCoordinates
 

spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_3D_coordinates.py

@@ -3,12 +3,14 @@ import os.path as op
 import pandas as pd
 
 from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
-from spatio_temporal_dataset.coordinates.transformed_coordinates.tranformation_3D import AnisotropyTransformation
+from spatio_temporal_dataset.coordinates.spatial_coordinates.abstract_spatial_coordinates import \
+    AbstractSpatialCoordinates
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.tranformation_3D import AnisotropyTransformation
 from spatio_temporal_dataset.coordinates.transformed_coordinates.transformed_coordinates import TransformedCoordinates
 from utils import get_full_path
 
 
-class AlpsStation3DCoordinates(AbstractCoordinates):
+class AlpsStation3DCoordinates(AbstractSpatialCoordinates):
     """
     For the Alps Stations, X, Y coordinates are in Lambert 2. Altitude is in meters
     """

spatio_temporal_dataset/coordinates/unidimensional_coordinates/coordinates_1D.py → spatio_temporal_dataset/coordinates/spatial_coordinates/coordinates_1D.py

@@ -4,13 +4,15 @@ import numpy as np
 from rpy2.robjects import r
 
 from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.abstract_spatial_coordinates import \
+    AbstractSpatialCoordinates
 
 
-class AbstractUniDimensionalCoordinates(AbstractCoordinates):
+class AbstractUniDimensionalSpatialCoordinates(AbstractSpatialCoordinates):
     pass
 
 
-class LinSpaceCoordinates(AbstractUniDimensionalCoordinates):
+class LinSpaceSpatialCoordinates(AbstractUniDimensionalSpatialCoordinates):
 
     @classmethod
     def from_nb_points(cls, nb_points, train_split_ratio: float = None, start=-1.0, end=1.0):
@@ -19,11 +21,16 @@ class LinSpaceCoordinates(AbstractUniDimensionalCoordinates):
         return cls.from_df(df, train_split_ratio)
 
 
-class UniformCoordinates(AbstractUniDimensionalCoordinates):
+class UniformSpatialCoordinates(AbstractUniDimensionalSpatialCoordinates):
 
     @classmethod
     def from_nb_points(cls, nb_points, train_split_ratio: float = None, start=-1.0, end=1.0):
         # Sample uniformly inside the circle
+        df = cls.df_spatial(nb_points, start, end)
+        return cls.from_df(df, train_split_ratio)
+
+    @classmethod
+    def df_spatial(cls, nb_points, start=-1.0, end=1.0):
         axis_coordinates = np.array(r.runif(nb_points, min=start, max=end))
         df = pd.DataFrame.from_dict({cls.COORDINATE_X: axis_coordinates})
-        return cls.from_df(df, train_split_ratio)
+        return df

spatio_temporal_dataset/coordinates/spatial_coordinates/generated_spatial_coordinates.py

@@ -6,8 +6,11 @@ from rpy2.robjects import r
 from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
 import matplotlib.pyplot as plt
 
+from spatio_temporal_dataset.coordinates.spatial_coordinates.abstract_spatial_coordinates import \
+    AbstractSpatialCoordinates
 
-class CircleCoordinates(AbstractCoordinates):
+
+class CircleSpatialCoordinates(AbstractSpatialCoordinates):
 
     @classmethod
     def df_spatial(cls, nb_points, max_radius=1.0):
@@ -31,7 +34,7 @@ class CircleCoordinates(AbstractCoordinates):
         super().visualization_2D()
 
 
-class CircleCoordinatesRadius2(CircleCoordinates):
+class CircleSpatialCoordinatesRadius2(CircleSpatialCoordinates):
 
     @classmethod
     def from_nb_points(cls, nb_points, train_split_ratio: float = None, max_radius=1.0):

spatio_temporal_dataset/coordinates/spatio_temporal_coordinates/abstract_spatio_temporal_coordinates.py

+import pandas as pd
+
+from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+from spatio_temporal_dataset.slicer.spatio_temporal_slicer import SpatioTemporalSlicer
+
+
+class AbstractSpatioTemporalCoordinates(AbstractCoordinates):
+
+    @classmethod
+    def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None):
+        assert cls.COORDINATE_T in df.columns
+        assert cls.COORDINATE_X in df.columns
+        return super().from_df_and_slicer(df, SpatioTemporalSlicer, train_split_ratio)
\ No newline at end of file

spatio_temporal_dataset/coordinates/spatio_temporal_coordinates/generated_spatio_temporal_coordinates.py

 import pandas as pd
 
 from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
-from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleCoordinates
+from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import UniformSpatialCoordinates
+from spatio_temporal_dataset.coordinates.spatio_temporal_coordinates.abstract_spatio_temporal_coordinates import \
+    AbstractSpatioTemporalCoordinates
 from spatio_temporal_dataset.slicer.spatio_temporal_slicer import SpatioTemporalSlicer
-from spatio_temporal_dataset.slicer.split import s_split_from_df
 
 
-class CircleTemporalCoordinates(CircleCoordinates):
+class UniformSpatioTemporalCoordinates(AbstractSpatioTemporalCoordinates):
 
     @classmethod
     def from_nb_points(cls, nb_points, train_split_ratio: float = None, nb_time_steps=1, max_radius=1.0):
         assert isinstance(nb_time_steps, int) and nb_time_steps >= 1
-        df_spatial = CircleCoordinates.df_spatial(nb_points, max_radius)
+        df_spatial = UniformSpatialCoordinates.df_spatial(nb_points)
         df_time_steps = []
         for t in range(nb_time_steps):
             df_time_step = df_spatial.copy()
             df_time_step[cls.COORDINATE_T] = t
             df_time_steps.append(df_time_step)
         df_time_steps = pd.concat(df_time_steps, ignore_index=True)
-        return AbstractCoordinates.from_df(df=df_time_steps, train_split_ratio=train_split_ratio,
-                                           slicer_class=SpatioTemporalSlicer)
+        print(df_time_steps)
+        return cls.from_df(df=df_time_steps, train_split_ratio=train_split_ratio)
+
+

spatio_temporal_dataset/coordinates/temporal_coordinates/abstract_temporal_coordinates.py

+import pandas as pd
+
+from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+from spatio_temporal_dataset.slicer.temporal_slicer import TemporalSlicer
+
+
+class AbstractTemporalCoordinates(AbstractCoordinates):
+
+    @classmethod
+    def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None):
+        assert cls.COORDINATE_T in df.columns
+        assert not any([coordinate_name in df.columns for coordinate_name in cls.COORDINATE_SPATIAL_NAMES])
+        return super().from_df_and_slicer(df, TemporalSlicer, train_split_ratio)
\ No newline at end of file

spatio_temporal_dataset/coordinates/temporal_coordinates/generated_temporal_coordinates.py

+from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+
+
+# class TemporalCoordinates(AbstractCoordinates):
+#     pass
+#
+#
+#     @classmethod
+#     def from_nb_points(cls, nb_points, train_split_ratio: float = None, start=-1.0, end=1.0):
+#         # Sample uniformly inside the circle
+#         df = cls.df_spatial(nb_points, start, end)
+#         return cls.from_df(df, train_split_ratio)
+#
+#     @classmethod
+#     def df_spatial(cls, nb_points, start=-1.0, end=1.0):
+#         axis_coordinates = np.array(r.runif(nb_points, min=start, max=end))
+#         df = pd.DataFrame.from_dict({cls.COORDINATE_X: axis_coordinates})
+#         return df
+#
+#     @classmethod
+#     def from_nb_points(cls, nb_points, train_split_ratio: float = None, nb_time_steps=1, max_radius=1.0):
+#         assert isinstance(nb_time_steps, int) and nb_time_steps >= 1
+#         df_spatial = UniformSpatialCoordinates.df_spatial(nb_points)
+#         df_time_steps = []
+#         for t in range(nb_time_steps):
+#             df_time_step = df_spatial.copy()
+#             df_time_step[cls.COORDINATE_T] = t
+#             df_time_steps.append(df_time_step)
+#         df_time_steps = pd.concat(df_time_steps, ignore_index=True)
+#         print(df_time_steps)
+#         return cls.from_df(df=df_time_steps, train_split_ratio=train_split_ratio, slicer_class=SpatioTemporalSlicer)
\ No newline at end of file

spatio_temporal_dataset/coordinates/transformed_coordinates/tranformation_3D.py → spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/tranformation_3D.py

 import pandas as pd
 import numpy as np
-from spatio_temporal_dataset.coordinates.transformed_coordinates.abstract_transformation import AbstractTransformation
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.abstract_transformation import AbstractTransformation
 import math