diff --git a/experiment/meteo_france_SCM_study/abstract_study.py b/experiment/meteo_france_SCM_study/abstract_study.py
index ab121ceae9e346cd05fa2a96c4f0ab0a8746d49d..1f2aac2d93704661043adb3675339b71963f74e2 100644
--- a/experiment/meteo_france_SCM_study/abstract_study.py
+++ b/experiment/meteo_france_SCM_study/abstract_study.py
@@ -160,14 +160,17 @@ class AbstractStudy(object):
@cached_property
def massifs_coordinates(self) -> AbstractSpatialCoordinates:
+ # Build coordinate object from df_centroid
+ return AbstractSpatialCoordinates.from_df(self.df_spatial())
+
+ def df_spatial(self):
# Coordinate object that represents the massif coordinates in Lambert extended
df_centroid = self.load_df_centroid()
for coord_column in [AbstractCoordinates.COORDINATE_X, AbstractCoordinates.COORDINATE_Y]:
df_centroid.loc[:, coord_column] = df_centroid[coord_column].str.replace(',', '.').astype(float)
# Filter, keep massifs present at the altitude of interest
df_centroid = df_centroid.loc[self.study_massif_names]
- # Build coordinate object from df_centroid
- return AbstractSpatialCoordinates.from_df(df_centroid)
+ return df_centroid
def load_df_centroid(self) -> pd.DataFrame:
# Load df_centroid containing all the massif names
diff --git a/experiment/meteo_france_SCM_study/visualization/study_visualization/main_study_visualizer.py b/experiment/meteo_france_SCM_study/visualization/study_visualization/main_study_visualizer.py
index 0abcf0e6a57a32c0db5e673329a17e469373c2c4..8a654900372da6ce03ede6e90d3ca50a1a0e49c5 100644
--- a/experiment/meteo_france_SCM_study/visualization/study_visualization/main_study_visualizer.py
+++ b/experiment/meteo_france_SCM_study/visualization/study_visualization/main_study_visualizer.py
@@ -7,8 +7,8 @@ from experiment.meteo_france_SCM_study.safran.safran import SafranSnowfall, Exte
from experiment.meteo_france_SCM_study.visualization.study_visualization.study_visualizer import StudyVisualizer
from collections import OrderedDict
-from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.transformation_2D import \
- BetweenZeroAndOne2DNormalization
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.uniform_normalization import \
+ BetweenZeroAndOneNormalization, BetweenMinusOneAndOneNormalization
SCM_STUDIES = [SafranSnowfall, CrocusSwe, CrocusDepth]
SCM_EXTENDED_STUDIES = [ExtendedSafranSnowfall, ExtendedCrocusSwe, ExtendedCrocusDepth]
@@ -114,15 +114,16 @@ def complete_analysis(only_first_one=False):
def trend_analysis():
- save_to_file = True
- only_first_one = False
+ save_to_file = False
+ only_first_one = True
# [0, 300, 600, 900, 1200, 1500, 1800, 2100, 2400, 2700, 3000, 3300, 3600, 3900, 4200, 4500, 4800] to test for others
altitudes = [300, 1200, 2100, 3000][-1:]
+ normalization_class = [BetweenZeroAndOneNormalization, BetweenMinusOneAndOneNormalization][1]
study_classes = [CrocusSwe, CrocusDepth, SafranSnowfall, SafranRainfall, SafranTemperature][:1]
for study in study_iterator_global(study_classes, only_first_one=only_first_one, altitudes=altitudes):
study_visualizer = StudyVisualizer(study, save_to_file=save_to_file,
- transformation_2D=BetweenZeroAndOne2DNormalization())
- study_visualizer.visualize_temporal_trend_relevance(complete_analysis=True)
+ transformation_class=normalization_class)
+ study_visualizer.visualize_temporal_trend_relevance(complete_analysis=False)
if __name__ == '__main__':
diff --git a/experiment/meteo_france_SCM_study/visualization/study_visualization/non_stationary_trends.py b/experiment/meteo_france_SCM_study/visualization/study_visualization/non_stationary_trends.py
index 77050e97f29b6436d3476a0b50f3f5ac7aba81d0..822268e9f8145ae01a006595e7fcdd29c33d5408 100644
--- a/experiment/meteo_france_SCM_study/visualization/study_visualization/non_stationary_trends.py
+++ b/experiment/meteo_france_SCM_study/visualization/study_visualization/non_stationary_trends.py
@@ -54,12 +54,7 @@ class AbstractNonStationaryTrendTest(object):
return margin_function.mu1_temporal_trend
def visualize(self, ax, complete_analysis=True):
- # Define the year_min and year_max for the starting point
- if complete_analysis:
- year_min, year_max, step = 1960, 1990, 1
- else:
- year_min, year_max, step = 1960, 1990, 10
- years = list(range(year_min, year_max + 1, step))
+ years = self.years(complete_analysis)
# Plot differences
stationary_metric = self.get_metric(self.stationary_margin_model_class, starting_point=None)
@@ -90,6 +85,15 @@ class AbstractNonStationaryTrendTest(object):
ax.set_title(title)
ax.legend()
+ def years(self, complete_analysis=True):
+ # Define the year_min and year_max for the starting point
+ if complete_analysis:
+ year_min, year_max, step = 1960, 1990, 1
+ else:
+ year_min, year_max, step = 1960, 1990, 10
+ years = list(range(year_min, year_max + 1, step))
+ return years
+
@property
def display_name(self):
raise NotImplementedError
diff --git a/experiment/meteo_france_SCM_study/visualization/study_visualization/study_visualizer.py b/experiment/meteo_france_SCM_study/visualization/study_visualization/study_visualizer.py
index f479d985a732b276d434425012f47a34fb6eac90..7fb9b0135c4c8b58962a24209fade298c96059ef 100644
--- a/experiment/meteo_france_SCM_study/visualization/study_visualization/study_visualizer.py
+++ b/experiment/meteo_france_SCM_study/visualization/study_visualization/study_visualizer.py
@@ -28,10 +28,12 @@ from extreme_estimator.margin_fits.gev.gev_params import GevParams
from extreme_estimator.margin_fits.gev.gevmle_fit import GevMleFit
from extreme_estimator.margin_fits.gpd.gpd_params import GpdParams
from extreme_estimator.margin_fits.gpd.gpdmle_fit import GpdMleFit
+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.transformed_coordinates.transformation.transformation_2D import \
- Transformation2D
+from spatio_temporal_dataset.coordinates.temporal_coordinates.generated_temporal_coordinates import \
+ ConsecutiveTemporalCoordinates
from spatio_temporal_dataset.coordinates.transformed_coordinates.transformed_coordinates import TransformedCoordinates
from spatio_temporal_dataset.dataset.abstract_dataset import AbstractDataset
from test.test_utils import load_test_max_stable_models
@@ -45,7 +47,7 @@ class StudyVisualizer(object):
def __init__(self, study: AbstractStudy, show=True, save_to_file=False, only_one_graph=False, only_first_row=False,
vertical_kde_plot=False, year_for_kde_plot=None, plot_block_maxima_quantiles=False,
temporal_non_stationarity=False,
- transformation_2D=None):
+ transformation_class=None):
self.temporal_non_stationarity = temporal_non_stationarity
self.only_first_row = only_first_row
self.only_one_graph = only_one_graph
@@ -59,7 +61,7 @@ class StudyVisualizer(object):
self._observations = None
self.default_covariance_function = CovarianceFunction.powexp
- self.transformation_2D = transformation_2D # type: Union[None, Transformation2D]
+ self.transformation_class = transformation_class
# KDE PLOT ARGUMENTS
self.vertical_kde_plot = vertical_kde_plot
@@ -91,21 +93,34 @@ class StudyVisualizer(object):
self._dataset = AbstractDataset(self.observations, self.coordinates)
return self._dataset
+ @property
+ def spatial_coordinates(self):
+ return AbstractSpatialCoordinates.from_df(df=self.study.df_spatial(),
+ transformation_class=self.transformation_class)
+
+ @property
+ def temporal_coordinates(self):
+ start, stop = self.study.start_year_and_stop_year
+ nb_steps = stop - start + 1
+ temporal_coordinates = ConsecutiveTemporalCoordinates.from_nb_temporal_steps(nb_temporal_steps=nb_steps,
+ start=start,
+ transformation_class=self.transformation_class)
+ return temporal_coordinates
+
+ @property
+ def spatio_temporal_coordinates(self):
+ return AbstractSpatioTemporalCoordinates.from_spatial_coordinates_and_temporal_coordinates(
+ spatial_coordinates=self.spatial_coordinates, temporal_coordinates=self.temporal_coordinates)
+
@property
def coordinates(self):
if self._coordinates is None:
- coordinates = self.study.massifs_coordinates
- if self.transformation_2D is not None:
- coordinates = TransformedCoordinates.from_coordinates(coordinates=coordinates,
- transformation_function=self.transformation_2D)
if self.temporal_non_stationarity:
- # Build spatio temporal dataset from a temporal dataset
- df_spatial = coordinates.df_spatial_coordinates()
- start, stop = self.study.start_year_and_stop_year
- nb_steps = stop - start + 1
- coordinates = AbstractSpatioTemporalCoordinates.from_df_spatial_and_nb_steps(df_spatial=df_spatial,
- nb_steps=nb_steps,
- start=start)
+ # Build spatio temporal coordinates from a spatial coordinates and a temporal coordinates
+ coordinates = self.spatio_temporal_coordinates
+ else:
+ # By default otherwise, we only keep the spatial coordinates
+ coordinates = self.spatial_coordinates
self._coordinates = coordinates
return self._coordinates
diff --git a/extreme_estimator/estimator/abstract_estimator.py b/extreme_estimator/estimator/abstract_estimator.py
index 857fef72b9d33d0f060412f036aba0f80a6ff04f..1b8ac471f656efc7a3a3d7321b799aa14ce0b34f 100644
--- a/extreme_estimator/estimator/abstract_estimator.py
+++ b/extreme_estimator/estimator/abstract_estimator.py
@@ -56,7 +56,7 @@ class AbstractEstimator(object):
return LinearMarginFunction.from_coef_dict(coordinates=self.dataset.coordinates,
gev_param_name_to_dims=margin_model.margin_function_start_fit.gev_param_name_to_dims,
coef_dict=self.result_from_fit.margin_coef_dict,
- starting_point=margin_model.starting_point)
+ starting_point=margin_model.transformed_starting_point)
# @property
# def max_stable_fitted(self) -> AbstractMarginFunction:
diff --git a/extreme_estimator/extreme_models/margin_model/fitspatgev.R b/extreme_estimator/extreme_models/margin_model/fitspatgev.R
index e7fd380e2f9ccec0a42126dda1a552ee262ac988..7b9525b74216ea7eb6e8b1b07dcf0c85460613f8 100644
--- a/extreme_estimator/extreme_models/margin_model/fitspatgev.R
+++ b/extreme_estimator/extreme_models/margin_model/fitspatgev.R
@@ -107,7 +107,6 @@ fitspatgev_3D_test <- function (n.obs){
loc.form <- update(loc.form, y ~ .)
scale.form <- update(scale.form, y ~ .)
shape.form <- update(shape.form, y ~ .)
- print('here')
print(use.temp.cov)
if (use.temp.cov[1])
temp.form.loc <- update(temp.form.loc, y ~ . + 0)
diff --git a/extreme_estimator/extreme_models/margin_model/linear_margin_model.py b/extreme_estimator/extreme_models/margin_model/linear_margin_model.py
index 14b1b7d9fdf8ce3d2f332f923567215b96be5c32..87f361f3e26d997f27bf6e1f5b8a6b57cbda9402 100644
--- a/extreme_estimator/extreme_models/margin_model/linear_margin_model.py
+++ b/extreme_estimator/extreme_models/margin_model/linear_margin_model.py
@@ -28,14 +28,14 @@ class LinearMarginModel(ParametricMarginModel):
self.margin_function_sample = LinearMarginFunction(coordinates=self.coordinates,
gev_param_name_to_coef=coef_sample,
gev_param_name_to_dims=gev_param_name_to_dims,
- starting_point=self.starting_point)
+ transformed_starting_point=self.transformed_starting_point)
# Load start fit coef
coef_start_fit = self.gev_param_name_to_linear_coef(param_name_and_dim_to_coef=self.params_start_fit)
self.margin_function_start_fit = LinearMarginFunction(coordinates=self.coordinates,
gev_param_name_to_coef=coef_start_fit,
gev_param_name_to_dims=gev_param_name_to_dims,
- starting_point=self.starting_point)
+ transformed_starting_point=self.transformed_starting_point)
@property
def default_param_name_and_dim_to_coef(self) -> dict:
diff --git a/extreme_estimator/extreme_models/margin_model/margin_function/independent_margin_function.py b/extreme_estimator/extreme_models/margin_model/margin_function/independent_margin_function.py
index 25350f19758727cef00a0844c8e92fa346319e65..74df6423ba8fcd0ca477b43519040cdce40ef38b 100644
--- a/extreme_estimator/extreme_models/margin_model/margin_function/independent_margin_function.py
+++ b/extreme_estimator/extreme_models/margin_model/margin_function/independent_margin_function.py
@@ -23,10 +23,11 @@ class IndependentMarginFunction(AbstractMarginFunction):
"""Each GEV parameter is computed independently through its corresponding param_function"""
assert self.gev_param_name_to_param_function is not None
assert len(self.gev_param_name_to_param_function) == 3
+ transformed_coordinate = self.coordinates.transform(coordinate)
gev_params = {}
for gev_param_name in GevParams.PARAM_NAMES:
param_function = self.gev_param_name_to_param_function[gev_param_name]
- gev_params[gev_param_name] = param_function.get_gev_param_value(coordinate)
+ gev_params[gev_param_name] = param_function.get_gev_param_value(transformed_coordinate)
return GevParams.from_dict(gev_params)
diff --git a/extreme_estimator/extreme_models/margin_model/margin_function/linear_margin_function.py b/extreme_estimator/extreme_models/margin_model/margin_function/linear_margin_function.py
index e65281cc3b291d794e8992530a2a664d39f70428..4c72f5faaf076bdcce3c541ab052d1312bb5c196 100644
--- a/extreme_estimator/extreme_models/margin_model/margin_function/linear_margin_function.py
+++ b/extreme_estimator/extreme_models/margin_model/margin_function/linear_margin_function.py
@@ -28,9 +28,9 @@ class LinearMarginFunction(ParametricMarginFunction):
COEF_CLASS = LinearCoef
def __init__(self, coordinates: AbstractCoordinates, gev_param_name_to_dims: Dict[str, List[int]],
- gev_param_name_to_coef: Dict[str, AbstractCoef], starting_point: Union[None, int] = None):
+ gev_param_name_to_coef: Dict[str, AbstractCoef], transformed_starting_point: Union[None, int] = None):
self.gev_param_name_to_coef = None # type: Union[None, Dict[str, LinearCoef]]
- super().__init__(coordinates, gev_param_name_to_dims, gev_param_name_to_coef, starting_point)
+ super().__init__(coordinates, gev_param_name_to_dims, gev_param_name_to_coef, transformed_starting_point)
def load_specific_param_function(self, gev_param_name) -> AbstractParamFunction:
return LinearParamFunction(dims=self.gev_param_name_to_dims[gev_param_name],
diff --git a/extreme_estimator/extreme_models/margin_model/margin_function/parametric_margin_function.py b/extreme_estimator/extreme_models/margin_model/margin_function/parametric_margin_function.py
index 09337e6d98986763a6eefb11746c1a34dbfd3395..601ebb8b43f5d2778db3fc3afcf7d6e63f066e9c 100644
--- a/extreme_estimator/extreme_models/margin_model/margin_function/parametric_margin_function.py
+++ b/extreme_estimator/extreme_models/margin_model/margin_function/parametric_margin_function.py
@@ -31,9 +31,9 @@ class ParametricMarginFunction(IndependentMarginFunction):
COEF_CLASS = None
def __init__(self, coordinates: AbstractCoordinates, gev_param_name_to_dims: Dict[str, List[int]],
- gev_param_name_to_coef: Dict[str, AbstractCoef], starting_point: Union[None, int] = None):
+ gev_param_name_to_coef: Dict[str, AbstractCoef], transformed_starting_point: Union[None, int] = None):
# Starting point for the trend is the same for all the parameters
- self.starting_point = starting_point
+ self.transformed_starting_point = transformed_starting_point
super().__init__(coordinates)
self.gev_param_name_to_dims = gev_param_name_to_dims # type: Dict[str, List[int]]
@@ -62,12 +62,12 @@ class ParametricMarginFunction(IndependentMarginFunction):
raise NotImplementedError
def get_gev_params(self, coordinate: np.ndarray) -> GevParams:
- if self.starting_point is not None:
+ if self.transformed_starting_point is not None:
# Shift temporal coordinate to enable to model temporal trend with starting point
assert self.coordinates.has_temporal_coordinates
assert 0 <= self.coordinates.idx_temporal_coordinates < len(coordinate)
- if coordinate[self.coordinates.idx_temporal_coordinates] < self.starting_point:
- coordinate[self.coordinates.idx_temporal_coordinates] = self.starting_point
+ if coordinate[self.coordinates.idx_temporal_coordinates] < self.transformed_starting_point:
+ coordinate[self.coordinates.idx_temporal_coordinates] = self.transformed_starting_point
return super().get_gev_params(coordinate)
@classmethod
diff --git a/extreme_estimator/extreme_models/margin_model/parametric_margin_model.py b/extreme_estimator/extreme_models/margin_model/parametric_margin_model.py
index f589f6ee697b501da11c713fb982d2df56bde4d0..7acacf8344c8933492417b43fe6263f89fce28d5 100644
--- a/extreme_estimator/extreme_models/margin_model/parametric_margin_model.py
+++ b/extreme_estimator/extreme_models/margin_model/parametric_margin_model.py
@@ -10,6 +10,10 @@ from extreme_estimator.extreme_models.margin_model.abstract_margin_model import
from extreme_estimator.extreme_models.utils import safe_run_r_estimator, r, get_coord, \
get_margin_formula
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+from spatio_temporal_dataset.coordinates.spatio_temporal_coordinates.abstract_spatio_temporal_coordinates import \
+ AbstractSpatioTemporalCoordinates
+from spatio_temporal_dataset.coordinates.temporal_coordinates.abstract_temporal_coordinates import \
+ AbstractTemporalCoordinates
class ParametricMarginModel(AbstractMarginModel, ABC):
@@ -19,19 +23,28 @@ class ParametricMarginModel(AbstractMarginModel, ABC):
"""
:param starting_point: starting coordinate for the temporal trend
"""
- self.starting_point = starting_point # type: int
+ # Load transformed starting point
+ if starting_point is None:
+ self.transformed_starting_point = None
+ else:
+ assert isinstance(coordinates, (AbstractSpatioTemporalCoordinates, AbstractTemporalCoordinates))
+ temporal_coordinate = np.array([starting_point])
+ self.transformed_starting_point = coordinates.temporal_coordinates.transform(temporal_coordinate)[0]
+
self.margin_function_sample = None # type: ParametricMarginFunction
self.margin_function_start_fit = None # type: ParametricMarginFunction
super().__init__(coordinates, use_start_value, params_start_fit, params_sample)
def add_starting_temporal_point(self, df_coordinates_temp: pd.DataFrame):
# Enforce a starting point for the temporal trend
- if self.starting_point is not None:
- ind_to_modify = df_coordinates_temp.iloc[:, 0] <= self.starting_point # type: pd.Series
+ if self.transformed_starting_point is not None:
+ # Compute the indices to modify
+ print('transformed starting point', self.transformed_starting_point)
+ ind_to_modify = df_coordinates_temp.iloc[:, 0] <= self.transformed_starting_point # type: pd.Series
# Assert that some coordinates are selected but not all (at least 20 data should be left for temporal trend)
assert 0 < sum(ind_to_modify) < len(ind_to_modify) - 20
# Modify the temporal coordinates to enforce the stationarity
- df_coordinates_temp.loc[ind_to_modify] = self.starting_point
+ df_coordinates_temp.loc[ind_to_modify] = self.transformed_starting_point
return df_coordinates_temp
def fitmargin_from_maxima_gev(self, data: np.ndarray, df_coordinates_spat: pd.DataFrame,
@@ -50,5 +63,5 @@ class ParametricMarginModel(AbstractMarginModel, ABC):
fit_params['start'] = r.list(**coef_dict)
res = safe_run_r_estimator(function=r.fitspatgev, use_start=self.use_start_value, data=data,
- covariables=covariables, **fit_params)
+ covariables=covariables, **fit_params)
return ResultFromSpatialExtreme(res)
diff --git a/extreme_estimator/margin_fits/gev/wrapper_ismev_gev_fit.R b/extreme_estimator/margin_fits/gev/wrapper_ismev_gev_fit.R
index 3eed3a0f49e277774ad0bd8a185b68d22d8a5955..0f6dc17031b4b5d8076f5aeb7925823fcb65fcd1 100644
--- a/extreme_estimator/margin_fits/gev/wrapper_ismev_gev_fit.R
+++ b/extreme_estimator/margin_fits/gev/wrapper_ismev_gev_fit.R
@@ -78,7 +78,6 @@ gev_fit_copy <- function (xdat, ydat = NULL, mul = NULL, sigl = NULL, shl = NULL
mu <- mulink(mumat %*% (a[1:npmu]))
sc <- siglink(sigmat %*% (a[seq(npmu + 1, length = npsc)]))
xi <- shlink(shmat %*% (a[seq(npmu + npsc + 1, length = npsh)]))
- print('here')
print(class(xdat))
print(class(mu))
y <- (xdat - mu)/sc
diff --git a/spatio_temporal_dataset/coordinates/abstract_coordinates.py b/spatio_temporal_dataset/coordinates/abstract_coordinates.py
index e81aea16c5297a129ab98aef69fd17ec158be94d..b269d60232718d3da23dcb1e22087a293b052326 100644
--- a/spatio_temporal_dataset/coordinates/abstract_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/abstract_coordinates.py
@@ -6,6 +6,8 @@ import numpy as np
import pandas as pd
from mpl_toolkits.mplot3d import Axes3D
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.abstract_transformation import \
+ AbstractTransformation, IdentityTransformation
from spatio_temporal_dataset.coordinates.utils import get_index_without_spatio_temporal_index_suffix
from spatio_temporal_dataset.slicer.abstract_slicer import AbstractSlicer, df_sliced
from spatio_temporal_dataset.slicer.spatial_slicer import SpatialSlicer
@@ -35,7 +37,7 @@ class AbstractCoordinates(object):
COORDINATES_NAMES = COORDINATE_SPATIAL_NAMES + [COORDINATE_T]
def __init__(self, df: pd.DataFrame, slicer_class: type, s_split_spatial: pd.Series = None,
- s_split_temporal: pd.Series = None):
+ s_split_temporal: pd.Series = None, transformation_class: type = None):
# Extract df_all_coordinates from df
coordinate_columns = [c for c in df.columns if c in self.COORDINATES_NAMES]
assert len(coordinate_columns) > 0
@@ -52,6 +54,13 @@ class AbstractCoordinates(object):
self.s_split_temporal = s_split_temporal # type: pd.Series
self.slicer = None # type: Union[None, AbstractSlicer]
+ # Transformation attribute
+ if transformation_class is None:
+ transformation_class = IdentityTransformation
+ # Transformation class is instantiated with all coordinates
+ self.transformation = transformation_class(self.df_all_coordinates)
+ assert isinstance(self.transformation, AbstractTransformation)
+
# Load the slicer
if slicer_class is TemporalSlicer:
self.slicer = TemporalSlicer(self.ind_train_temporal)
@@ -83,7 +92,8 @@ class AbstractCoordinates(object):
return cls(df=df, slicer_class=slicer_class, s_split_spatial=s_split_spatial, s_split_temporal=s_split_temporal)
@classmethod
- def from_df_and_slicer(cls, df: pd.DataFrame, slicer_class: type, train_split_ratio: float = None):
+ def from_df_and_slicer(cls, df: pd.DataFrame, slicer_class: type, train_split_ratio: float = None,
+ transformation_class: type = None):
# All the index should be unique
assert len(set(df.index)) == len(df), 'df indices are not unique'
@@ -92,7 +102,8 @@ class AbstractCoordinates(object):
# Create a temporal split
s_split_temporal = s_split_from_df(df, cls.COORDINATE_T, cls.TEMPORAL_SPLIT, train_split_ratio, False)
- return cls(df=df, slicer_class=slicer_class, s_split_spatial=s_split_spatial, s_split_temporal=s_split_temporal)
+ return cls(df=df, slicer_class=slicer_class, s_split_spatial=s_split_spatial, s_split_temporal=s_split_temporal,
+ transformation_class=transformation_class)
@classmethod
def from_csv(cls, csv_path: str = None):
@@ -114,10 +125,17 @@ class AbstractCoordinates(object):
# Merged DataFrame of df_coord with s_split
return self.df_all_coordinates.join(self.df_split)
+ # Normalize
+
+ def transform(self, coordinate: np.ndarray) -> np.ndarray:
+ return self.transformation.transform_array(coordinate=coordinate)
+
# Split
def df_coordinates(self, split: Split = Split.all) -> pd.DataFrame:
- return df_sliced(df=self.df_all_coordinates, split=split, slicer=self.slicer)
+ print(type(self.transformation))
+ df_transformed_coordinates = self.transformation.transform_df(df_coord=self.df_all_coordinates)
+ return df_sliced(df=df_transformed_coordinates, split=split, slicer=self.slicer)
def coordinates_values(self, split: Split = Split.all) -> np.ndarray:
return self.df_coordinates(split).values
@@ -293,4 +311,4 @@ class AbstractCoordinates(object):
return self.df_merged.equals(other.df_merged)
def __str__(self):
- return self.df_all_coordinates.__str__()
+ return self.df_coordinates().__str__()
diff --git a/spatio_temporal_dataset/coordinates/spatial_coordinates/abstract_spatial_coordinates.py b/spatio_temporal_dataset/coordinates/spatial_coordinates/abstract_spatial_coordinates.py
index f78456454fb9e747f4c22a10e6368aef08bfcc4e..ef7553bbc52aa32f35082bf12d1813ee81459bff 100644
--- a/spatio_temporal_dataset/coordinates/spatial_coordinates/abstract_spatial_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/spatial_coordinates/abstract_spatial_coordinates.py
@@ -1,16 +1,18 @@
import pandas as pd
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.abstract_transformation import \
+ AbstractTransformation
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):
+ def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None, transformation_class: type = 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)
+ return super().from_df_and_slicer(df, SpatialSlicer, train_split_ratio, transformation_class)
@classmethod
def from_nb_points(cls, nb_points: int, train_split_ratio: float = None, **kwargs):
diff --git a/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_2D_coordinates.py b/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_2D_coordinates.py
index 7cd62ddd26135437f0f708f6cdd508f67ce89ee3..c342b6d1ff4f14f68773319869d7b554eb9259ef 100644
--- a/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_2D_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_2D_coordinates.py
@@ -1,6 +1,6 @@
from spatio_temporal_dataset.coordinates.spatial_coordinates.alps_station_3D_coordinates import AlpsStation3DCoordinates
-from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.transformation_2D import \
- BetweenZeroAndOne2DNormalization
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.uniform_normalization import \
+ BetweenZeroAndOneNormalization
from spatio_temporal_dataset.coordinates.transformed_coordinates.transformed_coordinates import TransformedCoordinates
@@ -20,8 +20,7 @@ class AlpsStation2DCoordinatesBetweenZeroAndOne(AlpsStation2DCoordinates):
def from_csv(cls, csv_file='coord-lambert2'):
coord = super().from_csv(csv_file)
return TransformedCoordinates.from_coordinates(coordinates=coord,
- transformation_function=BetweenZeroAndOne2DNormalization())
-
+ transformation_class=BetweenZeroAndOneNormalization)
class AlpsStationCoordinatesBetweenZeroAndTwo(AlpsStation2DCoordinatesBetweenZeroAndOne):
diff --git a/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_3D_coordinates.py b/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_3D_coordinates.py
index 92e6ed424a7133b0557f2578dcf9154260b2e38b..92e97f8561a65733e2824af11cf6dd7434361c68 100644
--- a/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_3D_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/spatial_coordinates/alps_station_3D_coordinates.py
@@ -45,4 +45,4 @@ class AlpsStation3DCoordinatesWithAnisotropy(AlpsStation3DCoordinates):
def from_csv(cls, csv_file='coord-lambert2'):
coord = super().from_csv(csv_file)
return TransformedCoordinates.from_coordinates(coordinates=coord,
- transformation_function=AnisotropyTransformation())
+ transformation_class=AnisotropyTransformation)
diff --git a/spatio_temporal_dataset/coordinates/spatio_temporal_coordinates/abstract_spatio_temporal_coordinates.py b/spatio_temporal_dataset/coordinates/spatio_temporal_coordinates/abstract_spatio_temporal_coordinates.py
index 84b7feece54e3f123d2e07793bcb7626d70668c6..dc86c8c9f760af0757fc22f339558920db20ead5 100644
--- a/spatio_temporal_dataset/coordinates/spatio_temporal_coordinates/abstract_spatio_temporal_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/spatio_temporal_coordinates/abstract_spatio_temporal_coordinates.py
@@ -1,18 +1,61 @@
+import numpy as np
import pandas as pd
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
from spatio_temporal_dataset.coordinates.spatial_coordinates.abstract_spatial_coordinates import \
AbstractSpatialCoordinates
+from spatio_temporal_dataset.coordinates.temporal_coordinates.abstract_temporal_coordinates import \
+ AbstractTemporalCoordinates
from spatio_temporal_dataset.coordinates.utils import get_index_with_spatio_temporal_index_suffix
from spatio_temporal_dataset.slicer.spatio_temporal_slicer import SpatioTemporalSlicer
class AbstractSpatioTemporalCoordinates(AbstractCoordinates):
- def __init__(self, df: pd.DataFrame, slicer_class: type, s_split_spatial: pd.Series = None,
- s_split_temporal: pd.Series = None):
- super().__init__(df, slicer_class, s_split_spatial, s_split_temporal)
- self.spatial_coordinates = AbstractSpatialCoordinates.from_df(df=self.df_spatial_coordinates())
+ def __init__(self, df: pd.DataFrame, slicer_class: type,
+ s_split_spatial: pd.Series = None, s_split_temporal: pd.Series = None,
+ transformation_class: type = None,
+ spatial_coordinates: AbstractSpatialCoordinates = None,
+ temporal_coordinates: AbstractTemporalCoordinates = None):
+ super().__init__(df, slicer_class, s_split_spatial, s_split_temporal, transformation_class)
+ # Spatial coordinates'
+ if spatial_coordinates is None:
+ self.spatial_coordinates = AbstractSpatialCoordinates.from_df(df=self.df_spatial_coordinates())
+ else:
+ self.spatial_coordinates = spatial_coordinates
+ # Temporal coordinates
+ if temporal_coordinates is None:
+ self.temporal_coordinates = AbstractTemporalCoordinates.from_df(df=self.df_temporal_coordinates())
+ else:
+ self.temporal_coordinates = temporal_coordinates
+
+ def transform(self, coordinate: np.ndarray) -> np.ndarray:
+ *coordinate_spatial, coordinate_temporal = coordinate
+ transformed_coordinate_spatial = self.spatial_coordinates.transform(np.array(coordinate_spatial))
+ transformed_coordinate_temporal = self.temporal_coordinates.transform(np.array([coordinate_temporal]))
+ transformed_coordinate = np.concatenate([transformed_coordinate_spatial, transformed_coordinate_temporal])
+ return transformed_coordinate
+
+ @classmethod
+ def get_df_from_df_spatial_and_coordinate_t_values(cls, coordinate_t_values, df_spatial):
+ df_time_steps = []
+ for t, coordinate_t_value in enumerate(coordinate_t_values):
+ df_time_step = df_spatial.copy()
+ df_time_step[cls.COORDINATE_T] = coordinate_t_value
+ df_time_step.index = get_index_with_spatio_temporal_index_suffix(df_spatial, t)
+ df_time_steps.append(df_time_step)
+ df_time_steps = pd.concat(df_time_steps)
+ return df_time_steps
+
+ @classmethod
+ def from_spatial_coordinates_and_temporal_coordinates(cls, spatial_coordinates: AbstractSpatialCoordinates,
+ temporal_coordinates: AbstractTemporalCoordinates):
+ df_spatial = spatial_coordinates.df_spatial_coordinates()
+ coordinate_t_values = temporal_coordinates.df_temporal_coordinates().iloc[:, 0].values
+ df = cls.get_df_from_df_spatial_and_coordinate_t_values(df_spatial=df_spatial,
+ coordinate_t_values=coordinate_t_values)
+ return cls(df=df, slicer_class=SpatioTemporalSlicer,
+ spatial_coordinates=spatial_coordinates, temporal_coordinates=temporal_coordinates)
@classmethod
def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None):
@@ -25,14 +68,18 @@ class AbstractSpatioTemporalCoordinates(AbstractCoordinates):
return super().from_df_and_slicer(df, SpatioTemporalSlicer, train_split_ratio)
@classmethod
- def from_df_spatial_and_nb_steps(cls, df_spatial, nb_steps, train_split_ratio: float = None, start=0):
- df_time_steps = []
- for t in range(nb_steps):
- df_time_step = df_spatial.copy()
- df_time_step[cls.COORDINATE_T] = start + t
- df_time_step.index = get_index_with_spatio_temporal_index_suffix(df_spatial, t)
- df_time_steps.append(df_time_step)
- df_time_steps = pd.concat(df_time_steps)
+ def from_df_spatial_and_coordinate_t_values(cls, df_spatial, coordinate_t_values, train_split_ratio: float = None):
+ df_time_steps = cls.get_df_from_df_spatial_and_coordinate_t_values(coordinate_t_values, df_spatial)
return cls.from_df(df=df_time_steps, train_split_ratio=train_split_ratio)
+ @classmethod
+ def from_df_spatial_and_nb_steps(cls, df_spatial, nb_steps, train_split_ratio: float = None, start=0):
+ coordinate_t_values = [start + t for t in range(nb_steps)]
+ return cls.from_df_spatial_and_coordinate_t_values(df_spatial, coordinate_t_values, train_split_ratio)
+
+ @classmethod
+ def from_df_spatial_and_df_temporal(cls, df_spatial, df_temporal, train_split_ratio: float = None):
+ nb_steps = len(df_temporal)
+ coordinate_t_values = [df_temporal.iloc[t].values[0] for t in range(nb_steps)]
+ return cls.from_df_spatial_and_coordinate_t_values(df_spatial, coordinate_t_values, train_split_ratio)
diff --git a/spatio_temporal_dataset/coordinates/temporal_coordinates/abstract_temporal_coordinates.py b/spatio_temporal_dataset/coordinates/temporal_coordinates/abstract_temporal_coordinates.py
index f73a9cc2b0be078701baf0384c6e529f5b88e982..8084820e3788c1404d94e0cbe14ab07fc73b4b9f 100644
--- a/spatio_temporal_dataset/coordinates/temporal_coordinates/abstract_temporal_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/temporal_coordinates/abstract_temporal_coordinates.py
@@ -6,8 +6,12 @@ from spatio_temporal_dataset.slicer.temporal_slicer import TemporalSlicer
class AbstractTemporalCoordinates(AbstractCoordinates):
+ @property
+ def temporal_coordinates(self):
+ return self
+
@classmethod
- def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None):
+ def from_df(cls, df: pd.DataFrame, train_split_ratio: float = None, transformation_class: type = 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
+ return super().from_df_and_slicer(df, TemporalSlicer, train_split_ratio, transformation_class)
diff --git a/spatio_temporal_dataset/coordinates/temporal_coordinates/generated_temporal_coordinates.py b/spatio_temporal_dataset/coordinates/temporal_coordinates/generated_temporal_coordinates.py
index 518459725907c7a457d49bde000f787b8d7e9efd..766cd5e409c69c94b0533a87fa42f3c71601976e 100644
--- a/spatio_temporal_dataset/coordinates/temporal_coordinates/generated_temporal_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/temporal_coordinates/generated_temporal_coordinates.py
@@ -8,11 +8,14 @@ class ConsecutiveTemporalCoordinates(AbstractTemporalCoordinates):
pass
@classmethod
- def from_nb_temporal_steps(cls, nb_temporal_steps, train_split_ratio: float = None, start=0):
+ def from_nb_temporal_steps(cls, nb_temporal_steps, train_split_ratio: float = None, start=0,
+ transformation_class: type = None):
df = cls.df_temporal(nb_temporal_steps, start)
- return cls.from_df(df, train_split_ratio)
+ print(df.dtypes)
+ return cls.from_df(df, train_split_ratio, transformation_class=transformation_class)
@classmethod
def df_temporal(cls, nb_temporal_steps, start=0):
df = pd.DataFrame.from_dict({cls.COORDINATE_T: list(range(start, start + nb_temporal_steps))})
+ # df = df.astype
return df
diff --git a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/abstract_transformation.py b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/abstract_transformation.py
index 8c822f4f0ebfdd5683cb1d21b7f6c2b0a07cab63..77bfcebda3dc9564d37cea72a04da08c92c0f6b1 100644
--- a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/abstract_transformation.py
+++ b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/abstract_transformation.py
@@ -1,12 +1,29 @@
import pandas as pd
+import numpy as np
class AbstractTransformation(object):
- def __init__(self, nb_dimensions):
- self.nb_dimensions = nb_dimensions
+ def __init__(self, df_coordinates):
+ self.df_coordinates = df_coordinates
- def transform(self, df_coord: pd.DataFrame) -> pd.DataFrame:
- assert len(df_coord.columns) == self.nb_dimensions, "columns={}, nb_dimensions={}".format(df_coord.columns,
- self.nb_dimensions)
- return df_coord
+ @property
+ def nb_dimensions(self):
+ return self.df_coordinates.shape[1]
+
+ def transform_array(self, coordinate: np.ndarray):
+ assert len(coordinate) == self.nb_dimensions, "coordinate={}, nb_dimensions={}".format(coordinate,
+ self.nb_dimensions)
+
+ def transform_serie(self, s_coord: pd.Series) -> pd.Series:
+ return pd.Series(self.transform_array(s_coord.values), index=s_coord.index)
+
+ def transform_df(self, df_coord: pd.DataFrame) -> pd.DataFrame:
+ return df_coord.apply(self.transform_serie, axis=1)
+
+
+class IdentityTransformation(AbstractTransformation):
+
+ def transform_array(self, coordinate: np.ndarray):
+ super().transform_array(coordinate)
+ return coordinate
diff --git a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/tranformation_3D.py b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/tranformation_3D.py
index e0cd32fdf69c446fecb928f2865a29459e586ab6..c05f6436cb7414ac0dca1ba117f3c1c1b9f76c58 100644
--- a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/tranformation_3D.py
+++ b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/tranformation_3D.py
@@ -7,11 +7,8 @@ import math
class Transformation3D(AbstractTransformation):
- def __init__(self):
- super().__init__(nb_dimensions=3)
-
- def transform(self, df_coord: pd.DataFrame) -> pd.DataFrame:
- df_coord = super().transform(df_coord=df_coord)
+ def transform_df(self, df_coord: pd.DataFrame) -> pd.DataFrame:
+ df_coord = super().transform_df(df_coord=df_coord)
normalized_values = self.transform_values(df_coord.values)
return pd.DataFrame(data=normalized_values, index=df_coord.index, columns=df_coord.columns)
@@ -21,14 +18,14 @@ class Transformation3D(AbstractTransformation):
class AnisotropyTransformation(Transformation3D):
- def __init__(self, phi: float = 0.0, w1: float = 1.0, w2: float = 1.0):
+ def __init__(self, df_coordinates, phi: float = 0.0, w1: float = 1.0, w2: float = 1.0):
+ super().__init__(df_coordinates)
"""
Anisotropy transformation
:param phi: Between 0 and Pi, it corresponds to the angle of strongest dependence
:param w1: > 0, it corresponds to the anisotropy ratio
:param w2: it corresponds to the weight for the altitude
"""
- super().__init__()
self.phi = phi
self.w1 = w1
self.w2 = w2
@@ -46,6 +43,3 @@ class AnisotropyTransformation(Transformation3D):
coord_arr = np.transpose(coord_arr)
coord_arr = np.dot(V, coord_arr)
return np.transpose(coord_arr)
-
-
-
diff --git a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/transformation_2D.py b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/transformation_2D.py
deleted file mode 100644
index d92ec4ae13a304225eeb6d08ca0937a922bbdc60..0000000000000000000000000000000000000000
--- a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/transformation_2D.py
+++ /dev/null
@@ -1,48 +0,0 @@
-from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.abstract_transformation \
- import AbstractTransformation
-import pandas as pd
-
-
-class Transformation2D(AbstractTransformation):
-
- def __init__(self):
- super().__init__(nb_dimensions=2)
-
-
-class Uniform2DNormalization(Transformation2D):
- """Normalize similarly the X and Y axis with a single function so as to conserve proportional distances"""
-
- def transform(self, df_coord: pd.DataFrame) -> pd.DataFrame:
- df_coord = super().transform(df_coord)
- for i in range(2):
- df_coord.iloc[:, i] = self.uniform_normalization(df_coord.iloc[:, i])
- return df_coord
-
- def uniform_normalization(self, s_coord: pd.Series) -> pd.Series:
- return s_coord
-
-
-class BetweenZeroAndOne2DNormalization(Uniform2DNormalization):
- """Normalize such that min(coord) >= (0,0) and max(coord) <= (1,1)"""
-
- def __init__(self) -> None:
- super().__init__()
- self.min_coord = None
- self.max_coord = None
-
- def transform(self, df_coord: pd.DataFrame) -> pd.DataFrame:
- # Compute the min and max globally
- self.min_coord, self.max_coord = df_coord.min().min(), df_coord.max().max()
- # Then, call the super method that will call the uniform_normalization method
- return super().transform(df_coord)
-
- def uniform_normalization(self, s_coord: pd.Series) -> pd.Series:
- s_coord_shifted = s_coord - self.min_coord
- s_coord_scaled = s_coord_shifted / (self.max_coord - self.min_coord)
- return s_coord_scaled
-
-
-class BetweenMinusOneAndOne2DNormalization(BetweenZeroAndOne2DNormalization):
-
- def uniform_normalization(self, s_coord: pd.Series) -> pd.Series:
- pass
diff --git a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/uniform_normalization.py b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/uniform_normalization.py
new file mode 100644
index 0000000000000000000000000000000000000000..950679bd927f721de7ad0b92a62e292e7bc8be98
--- /dev/null
+++ b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformation/uniform_normalization.py
@@ -0,0 +1,41 @@
+import numpy as np
+
+from spatio_temporal_dataset.coordinates.transformed_coordinates.transformation.abstract_transformation \
+ import AbstractTransformation
+
+
+class UniformNormalization(AbstractTransformation):
+ """Normalize similarly the X and Y axis with a single function so as to conserve proportional distances"""
+
+ def transform_array(self, coordinate: np.ndarray):
+ super().transform_array(coordinate)
+ for i in range(self.nb_dimensions):
+ coordinate[i] = self.uniform_normalization(coordinate[i])
+ return coordinate
+
+ def uniform_normalization(self, coordinate_value: np.ndarray) -> np.ndarray:
+ return coordinate_value
+
+
+class BetweenZeroAndOneNormalization(UniformNormalization):
+ """Normalize such that min(coord) >= (0,0) and max(coord) <= (1,1)"""
+
+ def __init__(self, df_coordinates):
+ super().__init__(df_coordinates)
+ self.min_coord = self.df_coordinates.min().min()
+ self.max_coord = self.df_coordinates.max().max()
+
+ def uniform_normalization(self, coordinate_value: np.ndarray) -> np.ndarray:
+ coord_shifted = coordinate_value - self.min_coord
+ coord_scaled = coord_shifted / (self.max_coord - self.min_coord)
+ return coord_scaled
+
+
+class BetweenMinusOneAndOneNormalization(BetweenZeroAndOneNormalization):
+ """Normalize such that min(coord) >= (-1,-1) and max(coord) <= (1,1)"""
+
+ def uniform_normalization(self, coordinate_value: np.ndarray) -> np.ndarray:
+ coord = super().uniform_normalization(coordinate_value)
+ coord *= 2
+ coord -= 1
+ return coord
diff --git a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformed_coordinates.py b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformed_coordinates.py
index 3c4e1264d1e112002ec58e8bcd703d954b73bf0e..01a6811c0fc1e5540709adc2d202f1ecf2e5ffe9 100644
--- a/spatio_temporal_dataset/coordinates/transformed_coordinates/transformed_coordinates.py
+++ b/spatio_temporal_dataset/coordinates/transformed_coordinates/transformed_coordinates.py
@@ -7,9 +7,10 @@ class TransformedCoordinates(AbstractCoordinates):
@classmethod
def from_coordinates(cls, coordinates: AbstractCoordinates,
- transformation_function: AbstractTransformation):
- df_coordinates_transformed = coordinates.df_all_coordinates.copy()
- df_coordinates_transformed = transformation_function.transform(df_coord=df_coordinates_transformed)
+ transformation_class):
+ df_coordinates = coordinates.df_all_coordinates.copy()
+ transformation = transformation_class(df_coordinates) # type: AbstractTransformation
+ df_coordinates_transformed = transformation.transform_df(df_coordinates)
return cls(df=df_coordinates_transformed, slicer_class=type(coordinates.slicer),
s_split_spatial=coordinates.s_split_spatial, s_split_temporal=coordinates.s_split_temporal)
diff --git a/test/test_extreme_estimator/test_extreme_models/test_margin_temporal.py b/test/test_extreme_estimator/test_extreme_models/test_margin_temporal.py
index a533903e721490d7c3fb8f11461917df4385b93b..2388fcb35c781bf7cd1a1151f5fc2ee727604798 100644
--- a/test/test_extreme_estimator/test_extreme_models/test_margin_temporal.py
+++ b/test/test_extreme_estimator/test_extreme_models/test_margin_temporal.py
@@ -71,7 +71,7 @@ class TestMarginTemporal(unittest.TestCase):
self.smooth_margin_model.margin_function_sample.mu1_temporal_trend,
places=3)
# Checks starting point parameter are well passed
- self.assertEqual(2, estimator.margin_function_fitted.starting_point)
+ self.assertEqual(2, estimator.margin_function_fitted.transformed_starting_point)
# Checks that parameters returned are indeed different
coordinate1 = np.array([0.0, 0.0, 1])
mle_params_estimated_year1 = estimator.margin_function_fitted.get_gev_params(coordinate1).to_dict()
diff --git a/test/test_extreme_estimator/test_extreme_models/test_max_stable_temporal.py b/test/test_extreme_estimator/test_extreme_models/test_max_stable_temporal.py
index fa221e4b3d2d47d22a070ccbf50f53918ccdaecf..035c21c2d099f5bbb2f9b7059f5cc3697ced5863 100644
--- a/test/test_extreme_estimator/test_extreme_models/test_max_stable_temporal.py
+++ b/test/test_extreme_estimator/test_extreme_models/test_max_stable_temporal.py
@@ -77,7 +77,7 @@ class TestMaxStableTemporal(unittest.TestCase):
self.smooth_margin_model.margin_function_sample.mu1_temporal_trend,
places=2)
# Checks starting point parameter are well passed
- self.assertEqual(2, estimator.margin_function_fitted.starting_point)
+ self.assertEqual(2, estimator.margin_function_fitted.transformed_starting_point)
# Checks that parameters returned are indeed different
coordinate1 = np.array([0.0, 0.0, 1])
mle_params_estimated_year1 = estimator.margin_function_fitted.get_gev_params(coordinate1).to_dict()
diff --git a/test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_temporal.py b/test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_temporal.py
index 6977e111051e7797111f81f90aa0aeb810a32eca..249b5167c6a70b4838307f354998739495ae10e7 100644
--- a/test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_temporal.py
+++ b/test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_temporal.py
@@ -62,7 +62,7 @@ class TestGevTemporal(unittest.TestCase):
estimator = self.fit_non_stationary_estimator(starting_point=3)
self.assertNotEqual(estimator.margin_function_fitted.mu1_temporal_trend, 0.0)
# Checks starting point parameter are well passed
- self.assertEqual(3, estimator.margin_function_fitted.starting_point)
+ self.assertEqual(3, estimator.margin_function_fitted.transformed_starting_point)
# Checks that parameters returned are indeed different
mle_params_estimated_year1 = estimator.margin_function_fitted.get_gev_params(np.array([1])).to_dict()
mle_params_estimated_year3 = estimator.margin_function_fitted.get_gev_params(np.array([3])).to_dict()