[contrasting project] add spatio_temporal dataset to altitudes_studies.py

projects/contrasting_trends_in_snow_loads/altitunal_fit/altitudes_studies.py

@@ -12,6 +12,7 @@ from spatio_temporal_dataset.coordinates.spatio_temporal_coordinates.abstract_sp
 from spatio_temporal_dataset.coordinates.temporal_coordinates.generated_temporal_coordinates import \
     ConsecutiveTemporalCoordinates
 from spatio_temporal_dataset.dataset.abstract_dataset import AbstractDataset
+from spatio_temporal_dataset.spatio_temporal_observations.annual_maxima_observations import AnnualMaxima
 
 
 class AltitudesStudies(object):
@@ -22,7 +23,7 @@ class AltitudesStudies(object):
         self.spatial_transformation_class = spatial_transformation_class
         self.temporal_transformation_class = temporal_transformation_class
         self.altitudes = altitudes
-        self.altitude_to_study = OrderedDict()
+        self.altitude_to_study = OrderedDict() # type: OrderedDict[int, AbstractStudy]
         for altitude in self.altitudes:
             study = study_class(altitude=altitude, **kwargs_study)
             self.altitude_to_study[altitude] = study
@@ -31,11 +32,30 @@ class AltitudesStudies(object):
     def study(self) -> AbstractStudy:
         return list(self.altitude_to_study.values())[0]
 
-    def get_dataset(self, massif_name, slicer) -> AbstractDataset:
-        pass
+    # Dataset Loader
+
+    def spatio_temporal_dataset(self, massif_name, s_split_spatial: pd.Series = None, s_split_temporal: pd.Series = None):
+        coordinates = self.spatio_temporal_coordinates(s_split_spatial, s_split_temporal)
+        coordinate_values_to_maxima = {}
+        for altitude in self.altitudes:
+            study = self.altitude_to_study[altitude]
+            for year, maxima in zip(study.ordered_years, study.massif_name_to_annual_maxima[massif_name]):
+                coordinate_values_to_maxima[(altitude, year)] = [maxima]
+        observations = AnnualMaxima.from_coordinates(coordinates, coordinate_values_to_maxima)
+        return AbstractDataset(observations=observations, coordinates=coordinates)
 
     # Coordinates Loader
 
+    def spatio_temporal_coordinates(self, s_split_spatial: pd.Series = None, s_split_temporal: pd.Series = None):
+        slicer_class = AbstractCoordinates.slicer_class_from_s_splits(s_split_spatial=s_split_spatial,
+                                                                      s_split_temporal=s_split_temporal)
+        return AbstractSpatioTemporalCoordinates(slicer_class=slicer_class,
+                                                 s_split_spatial=s_split_spatial,
+                                                 s_split_temporal=s_split_temporal,
+                                                 transformation_class=self.spatial_transformation_class,
+                                                 spatial_coordinates=self.spatial_coordinates,
+                                                 temporal_coordinates=self.temporal_coordinates)
+
     @cached_property
     def temporal_coordinates(self):
         return ConsecutiveTemporalCoordinates.from_nb_temporal_steps(nb_temporal_steps=self.study.nb_years,
@@ -57,13 +77,3 @@ class AltitudesStudies(object):
 
     def random_s_split_temporal(self, train_split_ratio):
         return AbstractCoordinates.temporal_s_split_from_df(self._df_coordinates, train_split_ratio)
-
-    def spatio_temporal_coordinates(self, s_split_spatial: pd.Series = None, s_split_temporal: pd.Series = None):
-        slicer_class = AbstractCoordinates.slicer_class_from_s_splits(s_split_spatial=s_split_spatial,
-                                                                      s_split_temporal=s_split_temporal)
-        return AbstractSpatioTemporalCoordinates(slicer_class=slicer_class,
-                                                 s_split_spatial=s_split_spatial,
-                                                 s_split_temporal=s_split_temporal,
-                                                 transformation_class=self.spatial_transformation_class,
-                                                 spatial_coordinates=self.spatial_coordinates,
-                                                 temporal_coordinates=self.temporal_coordinates)

spatio_temporal_dataset/spatio_temporal_observations/annual_maxima_observations.py

@@ -15,11 +15,16 @@ from spatio_temporal_dataset.spatio_temporal_observations.daily_observations imp
 
 
 class AnnualMaxima(AbstractSpatioTemporalObservations):
-    """
-    Index are stations index
-    Columns are the annual of the maxima
-    """
-    pass
+
+    @classmethod
+    def from_coordinates(cls, coordinates: AbstractCoordinates, coordinate_values_to_maxima):
+        index_to_maxima = {}
+        for i, coordinate_values in coordinates.df_all_coordinates.iterrows():
+            coordinate_values = tuple([int(v) for v in coordinate_values])
+            index_to_maxima[i] = coordinate_values_to_maxima[coordinate_values]
+        df = pd.DataFrame(index_to_maxima).transpose()
+        df.index = coordinates.index
+        return cls(df_maxima_gev=df)
 
 
 class MarginAnnualMaxima(AnnualMaxima):

test/test_projects/test_contrasting/test_altitudes_studies.py

@@ -42,6 +42,36 @@ class TestSpatioTemporalCoordinates(TestAltitudesStudies):
         self.assertEqual(coordinates.coordinates_values(split=Split.test_spatiotemporal).shape, (1, 2))
 
 
+class TestSpatioTemporalDataset(TestAltitudesStudies):
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.massif_name = "Vercors"
+
+    def test_temporal_split(self):
+        s_split_temporal = self.studies.random_s_split_temporal(train_split_ratio=0.75)
+        dataset = self.studies.spatio_temporal_dataset(massif_name=self.massif_name,
+                                                       s_split_temporal=s_split_temporal)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.train_temporal)), 6)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.test_temporal)), 2)
+
+    def test_spatial_split(self):
+        s_split_spatial = self.studies.random_s_split_spatial(train_split_ratio=0.5)
+        dataset = self.studies.spatio_temporal_dataset(massif_name=self.massif_name,
+                                                       s_split_spatial=s_split_spatial)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.train_spatial)), 4)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.test_spatial)), 4)
+
+    def test_spatio_temporal_split(self):
+        s_split_spatial = self.studies.random_s_split_spatial(train_split_ratio=0.5)
+        s_split_temporal = self.studies.random_s_split_temporal(train_split_ratio=0.75)
+        dataset = self.studies.spatio_temporal_dataset(massif_name=self.massif_name,
+                                                       s_split_spatial=s_split_spatial,
+                                                       s_split_temporal=s_split_temporal)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.train_spatiotemporal)), 3)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.test_spatiotemporal)), 1)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.test_spatiotemporal_temporal)), 1)
+        self.assertEqual(len(dataset.maxima_gev(split=Split.test_spatiotemporal_spatial)), 3)
 
 
 if __name__ == '__main__':

test/test_spatio_temporal_dataset/test_spatio_temporal_observations.py

@@ -7,11 +7,16 @@ from extreme_fit.distribution.abstract_params import AbstractParams
 from extreme_fit.distribution.exp_params import ExpParams
 from extreme_fit.model.margin_model.linear_margin_model.temporal_linear_margin_models import StationaryTemporalModel
 from extreme_fit.model.utils import set_seed_for_test
+from spatio_temporal_dataset.coordinates.spatial_coordinates.abstract_spatial_coordinates import \
+    AbstractSpatialCoordinates
+from spatio_temporal_dataset.coordinates.spatio_temporal_coordinates.abstract_spatio_temporal_coordinates import \
+    AbstractSpatioTemporalCoordinates
 from spatio_temporal_dataset.coordinates.temporal_coordinates.generated_temporal_coordinates import \
     ConsecutiveTemporalCoordinates
 from spatio_temporal_dataset.spatio_temporal_observations.abstract_spatio_temporal_observations import \
     AbstractSpatioTemporalObservations
-from spatio_temporal_dataset.spatio_temporal_observations.annual_maxima_observations import DailyExpAnnualMaxima
+from spatio_temporal_dataset.spatio_temporal_observations.annual_maxima_observations import DailyExpAnnualMaxima, \
+    AnnualMaxima
 from spatio_temporal_dataset.spatio_temporal_observations.daily_observations import DailyExp
 
 
@@ -27,6 +32,23 @@ class TestSpatioTemporalObservations(unittest.TestCase):
         self.assertTrue(np.equal(example, maxima_frech).all(), msg="{} {}".format(example, maxima_frech))
 
 
+class TestAnnualMaximaFromDict(unittest.TestCase):
+
+    def test_annual_maxima_from_dict(self):
+        temporal_coordinates = ConsecutiveTemporalCoordinates.from_nb_temporal_steps(nb_temporal_steps=2)
+        spatial_coordinates = AbstractSpatialCoordinates.from_list_x_coordinates([300, 600])
+        coordinates = AbstractSpatioTemporalCoordinates(spatial_coordinates=spatial_coordinates,
+                                                        temporal_coordinates=temporal_coordinates)
+        coordinate_values_to_maxima = {
+            (300, 0): [1, 2],
+            (300, 1): [3, 4],
+            (600, 0): [1, 2],
+            (600, 1): [3, 4],
+        }
+        observations = AnnualMaxima.from_coordinates(coordinates, coordinate_values_to_maxima)
+        self.assertEqual(observations.df_maxima_gev.iloc[1, 1], 2)
+
+
 class TestDailyObservations(unittest.TestCase):
 
     def setUp(self) -> None: