From 7c9681944daad8d60887cb94c70ec9a3dd72be7d Mon Sep 17 00:00:00 2001
From: Le Roux Erwan <erwan.le-roux@irstea.fr>
Date: Sat, 18 Apr 2020 10:55:36 +0200
Subject: [PATCH] [refactor] gev_param_name -> param_name
---
.../visualization/create_shifted_cmap.py | 6 +-
.../visualization/study_visualizer.py | 16 ++---
extreme_fit/distribution/gev/gev_params.py | 6 +-
extreme_fit/estimator/utils.py | 2 +-
.../abstract_margin_function.py | 10 ++--
.../independent_margin_function.py | 10 ++--
.../margin_function/linear_margin_function.py | 37 ++++++------
.../parametric_margin_function.py | 46 +++++++--------
.../margin_function/spline_margin_function.py | 22 +++----
extreme_fit/function/margin_function/utils.py | 6 +-
.../function/param_function/abstract_coef.py | 8 +--
.../function/param_function/linear_coef.py | 18 +++---
.../function/param_function/spline_coef.py | 12 ++--
.../abstract_temporal_linear_margin_model.py | 10 ++--
.../linear_margin_model.py | 54 ++++++++---------
.../temporal_linear_margin_exp_models.py | 2 +-
.../temporal_linear_margin_models.py | 12 ++--
.../model/margin_model/spline_margin_model.py | 58 +++++++++----------
.../abstract_result_from_extremes.py | 12 ++--
.../result_from_bayesian_extremes.py | 8 +--
.../result_from_mle_extremes.py | 6 +-
.../result_from_ismev.py | 6 +-
.../model/result_from_model_fit/utils.py | 16 ++---
extreme_trend/abstract_gev_trend_test.py | 4 +-
.../gev_trend_test_one_parameter.py | 12 ++--
.../gumbel_trend_test_one_parameter.py | 4 +-
.../gev_trend_test_three_parameters.py | 4 +-
.../gev_trend_test_two_parameters.py | 4 +-
.../gumbel_test_two_parameters.py | 4 +-
.../main_bayesian_mcmc.py | 24 ++++----
.../daily_exp_simulation.py | 8 +--
.../gev_simulation.py | 12 ++--
.../test_function/test_margin_function.py | 6 +-
.../test_spatio_temporal_observations.py | 4 +-
.../test_rmaxstab_with_margin.py | 8 +--
35 files changed, 238 insertions(+), 239 deletions(-)
diff --git a/extreme_data/meteo_france_data/scm_models_data/visualization/create_shifted_cmap.py b/extreme_data/meteo_france_data/scm_models_data/visualization/create_shifted_cmap.py
index ed734262..e3ad6d16 100644
--- a/extreme_data/meteo_france_data/scm_models_data/visualization/create_shifted_cmap.py
+++ b/extreme_data/meteo_france_data/scm_models_data/visualization/create_shifted_cmap.py
@@ -49,7 +49,7 @@ def get_colors(values, cmap, vmin, vmax, replace_blue_by_white=False):
return colors
-def imshow_shifted(ax, gev_param_name, values, visualization_extend, mask_2D=None):
+def imshow_shifted(ax, param_name, values, visualization_extend, mask_2D=None):
condition = np.isnan(values)
if mask_2D is not None:
condition |= mask_2D
@@ -57,9 +57,9 @@ def imshow_shifted(ax, gev_param_name, values, visualization_extend, mask_2D=Non
vmin, vmax = np.min(masked_array), np.max(masked_array)
shifted_cmap = get_shifted_map(vmin, vmax)
norm = get_norm(vmin, vmax)
- create_colorbase_axis(ax, gev_param_name, shifted_cmap, norm)
+ create_colorbase_axis(ax, param_name, shifted_cmap, norm)
shifted_cmap.set_bad(color='white')
- if gev_param_name != AbstractParams.SHAPE:
+ if param_name != AbstractParams.SHAPE:
epsilon = 1e-2 * (np.max(values) - np.min(values))
value = np.min(values)
# The right blue corner will be blue (but most of the time, another display will be on top)
diff --git a/extreme_data/meteo_france_data/scm_models_data/visualization/study_visualizer.py b/extreme_data/meteo_france_data/scm_models_data/visualization/study_visualizer.py
index 8a4fa435..603b4020 100644
--- a/extreme_data/meteo_france_data/scm_models_data/visualization/study_visualizer.py
+++ b/extreme_data/meteo_france_data/scm_models_data/visualization/study_visualizer.py
@@ -583,11 +583,11 @@ class StudyVisualizer(VisualizationParameters):
fig, axes = plt.subplots(1, len(params_names))
fig.subplots_adjust(hspace=self.subplot_space, wspace=self.subplot_space)
- for i, gev_param_name in enumerate(params_names):
+ for i, param_name in enumerate(params_names):
ax = axes[i]
- self.study.visualize_study(ax=ax, massif_name_to_value=df.loc[gev_param_name, :].to_dict(), show=False,
- replace_blue_by_white=gev_param_name != GevParams.SHAPE,
- label=gev_param_name)
+ self.study.visualize_study(ax=ax, massif_name_to_value=df.loc[param_name, :].to_dict(), show=False,
+ replace_blue_by_white=param_name != GevParams.SHAPE,
+ label=param_name)
self.clean_axes_write_title_on_the_left(axes, title='Independent fits')
if show:
@@ -613,12 +613,12 @@ class StudyVisualizer(VisualizationParameters):
# 2) Second row, gev parameters fitted independently (and a qqplot)
axes_second_row = axes[1]
- for ax, gev_param_name in zip(axes_second_row, GevParams.PARAM_NAMES):
+ for ax, param_name in zip(axes_second_row, GevParams.PARAM_NAMES):
self.study.visualize_study(ax=ax,
- massif_name_to_value=self.df_gev_parameters.loc[gev_param_name, :].to_dict(),
+ massif_name_to_value=self.df_gev_parameters.loc[param_name, :].to_dict(),
show=False,
- replace_blue_by_white=gev_param_name != GevParams.SHAPE,
- label=gev_param_name)
+ replace_blue_by_white=param_name != GevParams.SHAPE,
+ label=param_name)
# todo: add qqplot drawn for each massif on the map in the last cell
# or just it could be some fitting score based on the qqplot... and we just display the value
# like the log likelihood, (or we could also display some uncertainty here)
diff --git a/extreme_fit/distribution/gev/gev_params.py b/extreme_fit/distribution/gev/gev_params.py
index ce34b36b..195a5b18 100644
--- a/extreme_fit/distribution/gev/gev_params.py
+++ b/extreme_fit/distribution/gev/gev_params.py
@@ -124,13 +124,13 @@ class GevParams(AbstractExtremeParams):
return indicator_name_to_value
@classmethod
- def greek_letter_from_gev_param_name(cls, gev_param_name):
- assert gev_param_name in cls.PARAM_NAMES
+ def greek_letter_from_param_name(cls, param_name):
+ assert param_name in cls.PARAM_NAMES
return {
cls.LOC: 'mu',
cls.SCALE: 'sigma',
cls.SHAPE: 'zeta',
- }[gev_param_name]
+ }[param_name]
def gumbel_standardization(self, x):
x -= self.location
diff --git a/extreme_fit/estimator/utils.py b/extreme_fit/estimator/utils.py
index 8debd940..a7446b45 100644
--- a/extreme_fit/estimator/utils.py
+++ b/extreme_fit/estimator/utils.py
@@ -10,7 +10,7 @@ def load_margin_function(estimator: AbstractEstimator, margin_model: LinearMargi
if coef_dict is None:
coef_dict = estimator.result_from_model_fit.margin_coef_ordered_dict
return margin_function_class.from_coef_dict(coordinates=estimator.dataset.coordinates,
- gev_param_name_to_dims=margin_model.margin_function_start_fit.gev_param_name_to_dims,
+ param_name_to_dims=margin_model.margin_function_start_fit.param_name_to_dims,
coef_dict=coef_dict,
starting_point=margin_model.starting_point)
diff --git a/extreme_fit/function/margin_function/abstract_margin_function.py b/extreme_fit/function/margin_function/abstract_margin_function.py
index 4a424e1c..a271da29 100644
--- a/extreme_fit/function/margin_function/abstract_margin_function.py
+++ b/extreme_fit/function/margin_function/abstract_margin_function.py
@@ -163,12 +163,12 @@ class AbstractMarginFunction(AbstractFunction):
# Visualization 2D
- def visualize_2D(self, gev_param_name=GevParams.LOC, ax=None, show=True, temporal_step=None):
+ def visualize_2D(self, param_name=GevParams.LOC, ax=None, show=True, temporal_step=None):
if ax is None:
ax = plt.gca()
# Special display
- imshow_shifted(ax, gev_param_name, self.grid_2D(temporal_step)[gev_param_name], self.visualization_extend,
+ imshow_shifted(ax, param_name, self.grid_2D(temporal_step)[param_name], self.visualization_extend,
self.mask_2D)
# X axis
@@ -223,7 +223,7 @@ class AbstractMarginFunction(AbstractFunction):
# Visualization 3D
- def visualize_2D_spatial_1D_temporal(self, gev_param_name=GevParams.LOC, axes=None, show=True):
+ def visualize_2D_spatial_1D_temporal(self, param_name=GevParams.LOC, axes=None, show=True):
if axes is None:
axes = create_adjusted_axes(self.VISUALIZATION_TEMPORAL_STEPS, 1)
assert len(axes) == self.VISUALIZATION_TEMPORAL_STEPS
@@ -231,8 +231,8 @@ class AbstractMarginFunction(AbstractFunction):
# Build temporal_steps a list of time steps
assert len(self.temporal_steps) == self.VISUALIZATION_TEMPORAL_STEPS
for ax, temporal_step in zip(axes, self.temporal_steps):
- self.visualize_2D(gev_param_name, ax, show=False, temporal_step=temporal_step)
- self.set_title(ax, gev_param_name)
+ self.visualize_2D(param_name, ax, show=False, temporal_step=temporal_step)
+ self.set_title(ax, param_name)
if show:
plt.show()
diff --git a/extreme_fit/function/margin_function/independent_margin_function.py b/extreme_fit/function/margin_function/independent_margin_function.py
index bdd14bfc..b1d6b54a 100644
--- a/extreme_fit/function/margin_function/independent_margin_function.py
+++ b/extreme_fit/function/margin_function/independent_margin_function.py
@@ -15,19 +15,19 @@ class IndependentMarginFunction(AbstractMarginFunction):
"""
def __init__(self, coordinates: AbstractCoordinates, params_class: type = GevParams):
- """Attribute 'gev_param_name_to_param_function' maps each GEV parameter to its corresponding function"""
+ """Attribute 'param_name_to_param_function' maps each GEV parameter to its corresponding function"""
super().__init__(coordinates, params_class)
- self.gev_param_name_to_param_function = None # type: Union[None, Dict[str, AbstractParamFunction]]
+ self.param_name_to_param_function = None # type: Union[None, Dict[str, AbstractParamFunction]]
def get_params(self, coordinate: np.ndarray, is_transformed: bool = True) -> GevParams:
"""Each GEV parameter is computed independently through its corresponding param_function"""
# Since all the coordinates are usually transformed by default
# then we assume that the input coordinate are transformed by default
- assert self.gev_param_name_to_param_function is not None
- assert len(self.gev_param_name_to_param_function) == len(self.params_class.PARAM_NAMES)
+ assert self.param_name_to_param_function is not None
+ assert len(self.param_name_to_param_function) == len(self.params_class.PARAM_NAMES)
transformed_coordinate = coordinate if is_transformed else self.transform(coordinate)
params = {param_name: param_function.get_param_value(transformed_coordinate)
- for param_name, param_function in self.gev_param_name_to_param_function.items()}
+ for param_name, param_function in self.param_name_to_param_function.items()}
return self.params_class.from_dict(params)
diff --git a/extreme_fit/function/margin_function/linear_margin_function.py b/extreme_fit/function/margin_function/linear_margin_function.py
index 81a9ee8d..3ef5baae 100644
--- a/extreme_fit/function/margin_function/linear_margin_function.py
+++ b/extreme_fit/function/margin_function/linear_margin_function.py
@@ -19,25 +19,24 @@ class LinearMarginFunction(ParametricMarginFunction):
dim = 2 correspond to the second coordinate
dim = 3 correspond to the third coordinate....
- gev_param_name_to_linear_dims maps each parameter of the GEV distribution to its linear dimensions
+ param_name_to_linear_dims maps each parameter of the GEV distribution to its linear dimensions
- gev_param_name_to_linear_coef maps each parameter of the GEV distribution to its linear coefficients
+ param_name_to_linear_coef maps each parameter of the GEV distribution to its linear coefficients
"""
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,
+ def __init__(self, coordinates: AbstractCoordinates, param_name_to_dims: Dict[str, List[int]],
+ param_name_to_coef: Dict[str, AbstractCoef], starting_point: Union[None, int] = None,
params_class: type = GevParams):
- 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,
- params_class)
+ self.param_name_to_coef = None # type: Union[None, Dict[str, LinearCoef]]
+ super().__init__(coordinates, param_name_to_dims, param_name_to_coef, starting_point, params_class)
- def load_specific_param_function(self, gev_param_name) -> AbstractParamFunction:
- return LinearParamFunction(dims=self.gev_param_name_to_dims[gev_param_name],
+ def load_specific_param_function(self, param_name) -> AbstractParamFunction:
+ return LinearParamFunction(dims=self.param_name_to_dims[param_name],
coordinates=self.coordinates.coordinates_values(),
- linear_coef=self.gev_param_name_to_coef[gev_param_name])
+ linear_coef=self.param_name_to_coef[param_name])
@classmethod
def idx_to_coefficient_name(cls, coordinates: AbstractCoordinates) -> Dict[int, str]:
@@ -55,9 +54,9 @@ class LinearMarginFunction(ParametricMarginFunction):
@property
def coef_dict(self) -> Dict[str, float]:
coef_dict = {}
- for gev_param_name in GevParams.PARAM_NAMES:
- dims = self.gev_param_name_to_dims.get(gev_param_name, [])
- coef = self.gev_param_name_to_coef[gev_param_name]
+ for param_name in self.params_class.PARAM_NAMES:
+ dims = self.param_name_to_dims.get(param_name, [])
+ coef = self.param_name_to_coef[param_name]
coef_dict.update(coef.coef_dict(dims, self.idx_to_coefficient_name(self.coordinates)))
return coef_dict
@@ -68,19 +67,19 @@ class LinearMarginFunction(ParametricMarginFunction):
@property
def form_dict(self) -> Dict[str, str]:
form_dict = {}
- for gev_param_name in self.params_class.PARAM_NAMES:
- linear_dims = self.gev_param_name_to_dims.get(gev_param_name, [])
+ for param_name in self.params_class.PARAM_NAMES:
+ linear_dims = self.param_name_to_dims.get(param_name, [])
# Load spatial form_dict (only if we have some spatial coordinates)
if self.coordinates.has_spatial_coordinates:
spatial_names = [name for name in self.coordinates.spatial_coordinates_names
if self.coefficient_name_to_dim(self.coordinates)[name] in linear_dims]
- spatial_form = self.gev_param_name_to_coef[gev_param_name].spatial_form_dict(spatial_names)
+ spatial_form = self.param_name_to_coef[param_name].spatial_form_dict(spatial_names)
form_dict.update(spatial_form)
# Load temporal form dict (only if we have some temporal coordinates)
if self.coordinates.has_temporal_coordinates:
temporal_names = [name for name in self.coordinates.temporal_coordinates_names
if self.coefficient_name_to_dim(self.coordinates)[name] in linear_dims]
- temporal_form = self.gev_param_name_to_coef[gev_param_name].temporal_form_dict(temporal_names)
+ temporal_form = self.param_name_to_coef[param_name].temporal_form_dict(temporal_names)
# Specifying a formula '~ 1' creates a bug in fitspatgev of SpatialExtreme R package
assert not any(['1' in formula for formula in temporal_form.values()])
form_dict.update(temporal_form)
@@ -88,10 +87,10 @@ class LinearMarginFunction(ParametricMarginFunction):
# Properties for the location parameter
- def get_coef(self, gev_param_name, coef_name):
+ def get_coef(self, param_name, coef_name):
idx = 1 if coef_name in [AbstractCoordinates.COORDINATE_T, LinearCoef.INTERCEPT_NAME] \
else AbstractCoordinates.COORDINATE_SPATIAL_NAMES.index(coef_name) + 2
- return self.coef_dict[LinearCoef.coef_template_str(gev_param_name, coef_name).format(idx)]
+ return self.coef_dict[LinearCoef.coef_template_str(param_name, coef_name).format(idx)]
@property
def mu1_temporal_trend(self):
diff --git a/extreme_fit/function/margin_function/parametric_margin_function.py b/extreme_fit/function/margin_function/parametric_margin_function.py
index f6964588..e47e4054 100644
--- a/extreme_fit/function/margin_function/parametric_margin_function.py
+++ b/extreme_fit/function/margin_function/parametric_margin_function.py
@@ -17,49 +17,49 @@ class ParametricMarginFunction(IndependentMarginFunction):
-depend on some integer dimensions (dimension 1 or/and dimension 2 for instance).
Coordinate name corresponding to the dimension depends on the order of the columns of self.coordinates
- gev_param_name_to_dims maps each GEV parameter to its corresponding dimensions
+ param_name_to_dims maps each GEV parameter to its corresponding dimensions
-have a set of all potential coefficient that could be used to define a function
- gev_param_name_to_coef maps each GEV parameter to an AbstractCoef object. This object contains
+ param_name_to_coef maps each GEV parameter to an AbstractCoef object. This object contains
-combining the integer dimensions & the set of all potential coefficient
to keep only the relevant coefficient, and build the corresponding function from that
- gev_param_name_to_param_function maps each GEV parameter to a AbstractParamFunction object.
+ param_name_to_param_function maps each GEV parameter to a AbstractParamFunction object.
"""
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,
+ def __init__(self, coordinates: AbstractCoordinates, param_name_to_dims: Dict[str, List[int]],
+ param_name_to_coef: Dict[str, AbstractCoef], starting_point: Union[None, int] = None,
params_class: type = GevParams):
# Starting point for the trend is the same for all the parameters
self.starting_point = starting_point
super().__init__(coordinates, params_class)
- self.gev_param_name_to_dims = gev_param_name_to_dims # type: Dict[str, List[int]]
+ self.param_name_to_dims = param_name_to_dims # type: Dict[str, List[int]]
# Check the dimension are well-defined with respect to the coordinates
- for dims in self.gev_param_name_to_dims.values():
+ for dims in self.param_name_to_dims.values():
for dim in dims:
assert 0 <= dim < coordinates.nb_coordinates, \
"dim={}, nb_columns={}".format(dim, coordinates.nb_coordinates)
- self.gev_param_name_to_coef = gev_param_name_to_coef # type: Dict[str, AbstractCoef]
+ self.param_name_to_coef = param_name_to_coef # type: Dict[str, AbstractCoef]
# Build gev_parameter_to_param_function dictionary
- self.gev_param_name_to_param_function = {} # type: Dict[str, AbstractParamFunction]
- # Map each gev_param_name to its corresponding param_function
- for gev_param_name in self.params_class.PARAM_NAMES:
+ self.param_name_to_param_function = {} # type: Dict[str, AbstractParamFunction]
+ # Map each param_name to its corresponding param_function
+ for param_name in self.params_class.PARAM_NAMES:
# By default, if dims are not specified, a constantParamFunction is chosen
- if self.gev_param_name_to_dims.get(gev_param_name) is None:
- param_function = ConstantParamFunction(constant=self.gev_param_name_to_coef[gev_param_name].intercept)
+ if self.param_name_to_dims.get(param_name) is None:
+ param_function = ConstantParamFunction(constant=self.param_name_to_coef[param_name].intercept)
# Otherwise, we load a specific param function
else:
- param_function = self.load_specific_param_function(gev_param_name)
+ param_function = self.load_specific_param_function(param_name)
# In both cases, we add the param_function to the dictionary
- self.gev_param_name_to_param_function[gev_param_name] = param_function
+ self.param_name_to_param_function[param_name] = param_function
- def load_specific_param_function(self, gev_param_name) -> AbstractParamFunction:
+ def load_specific_param_function(self, param_name) -> AbstractParamFunction:
raise NotImplementedError
@property
@@ -77,16 +77,16 @@ class ParametricMarginFunction(IndependentMarginFunction):
return super().get_params(coordinate, is_transformed=is_transformed)
@classmethod
- def from_coef_dict(cls, coordinates: AbstractCoordinates, gev_param_name_to_dims: Dict[str, List[int]],
+ def from_coef_dict(cls, coordinates: AbstractCoordinates, param_name_to_dims: Dict[str, List[int]],
coef_dict: Dict[str, float], starting_point: Union[None, int] = None):
assert cls.COEF_CLASS is not None, 'a COEF_CLASS class attributes needs to be defined'
- gev_param_name_to_coef = {}
- for gev_param_name in GevParams.PARAM_NAMES:
- dims = gev_param_name_to_dims.get(gev_param_name, [])
- coef = cls.COEF_CLASS.from_coef_dict(coef_dict=coef_dict, gev_param_name=gev_param_name, dims=dims,
+ param_name_to_coef = {}
+ for param_name in GevParams.PARAM_NAMES:
+ dims = param_name_to_dims.get(param_name, [])
+ coef = cls.COEF_CLASS.from_coef_dict(coef_dict=coef_dict, param_name=param_name, dims=dims,
coordinates=coordinates)
- gev_param_name_to_coef[gev_param_name] = coef
- return cls(coordinates, gev_param_name_to_dims, gev_param_name_to_coef, starting_point)
+ param_name_to_coef[param_name] = coef
+ return cls(coordinates, param_name_to_dims, param_name_to_coef, starting_point)
@property
def form_dict(self) -> Dict[str, str]:
diff --git a/extreme_fit/function/margin_function/spline_margin_function.py b/extreme_fit/function/margin_function/spline_margin_function.py
index d7f9cb2b..f3513046 100644
--- a/extreme_fit/function/margin_function/spline_margin_function.py
+++ b/extreme_fit/function/margin_function/spline_margin_function.py
@@ -13,7 +13,7 @@ from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoo
class SplineMarginFunction(ParametricMarginFunction):
"""
- -gev_param_name_to_dims maps each GEV parameters to its correspond knot dimensions.
+ -param_name_to_dims maps each GEV parameters to its correspond knot dimensions.
For instance, dims = [1,2] means the knot will be realized with 2D knots
dims = [1] means the knot will lie only on the first axis
@@ -21,16 +21,16 @@ class SplineMarginFunction(ParametricMarginFunction):
COEF_CLASS = SplineCoef
- def __init__(self, coordinates: AbstractCoordinates, gev_param_name_to_dims: Dict[str, List[int]],
- gev_param_name_to_coef: Dict[str, AbstractCoef],
- gev_param_name_to_nb_knots: Dict[str, int],
+ def __init__(self, coordinates: AbstractCoordinates, param_name_to_dims: Dict[str, List[int]],
+ param_name_to_coef: Dict[str, AbstractCoef],
+ param_name_to_nb_knots: Dict[str, int],
degree=3):
- self.gev_param_name_to_coef = None # type: Dict[str, SplineCoef]
+ self.param_name_to_coef = None # type: Dict[str, SplineCoef]
# Attributes specific for SplineMarginFunction
- self.gev_param_name_to_nb_knots = gev_param_name_to_nb_knots
+ self.param_name_to_nb_knots = param_name_to_nb_knots
assert degree % 2 == 1
self.degree = degree
- super().__init__(coordinates, gev_param_name_to_dims, gev_param_name_to_coef)
+ super().__init__(coordinates, param_name_to_dims, param_name_to_coef)
def compute_knots(self, dims, nb_knots) -> np.ndarray:
@@ -47,10 +47,10 @@ class SplineMarginFunction(ParametricMarginFunction):
"""
pass
- def load_specific_param_function(self, gev_param_name) -> AbstractParamFunction:
- dims = self.gev_param_name_to_dims[gev_param_name]
- coef = self.gev_param_name_to_coef[gev_param_name]
- nb_knots = self.gev_param_name_to_nb_knots[gev_param_name]
+ def load_specific_param_function(self, param_name) -> AbstractParamFunction:
+ dims = self.param_name_to_dims[param_name]
+ coef = self.param_name_to_coef[param_name]
+ nb_knots = self.param_name_to_nb_knots[param_name]
knots = self.compute_knots(dims, nb_knots)
return SplineParamFunction(dims=dims, degree=self.degree, spline_coef=coef, knots=knots)
diff --git a/extreme_fit/function/margin_function/utils.py b/extreme_fit/function/margin_function/utils.py
index 5f5fdac2..3ab12fc8 100644
--- a/extreme_fit/function/margin_function/utils.py
+++ b/extreme_fit/function/margin_function/utils.py
@@ -20,8 +20,8 @@ def error_dict_between_margin_functions(reference: AbstractMarginFunction, fitte
'Coordinates have either been resampled or the split is not the same'
reference_values = reference.gev_value_name_to_serie
fitted_values = fitted.gev_value_name_to_serie
- gev_param_name_to_error_serie = {}
+ param_name_to_error_serie = {}
for gev_value_name in GevParams.SUMMARY_NAMES:
error = 100 * relative_abs_error(reference_values[gev_value_name], fitted_values[gev_value_name])
- gev_param_name_to_error_serie[gev_value_name] = error
- return gev_param_name_to_error_serie
+ param_name_to_error_serie[gev_value_name] = error
+ return param_name_to_error_serie
diff --git a/extreme_fit/function/param_function/abstract_coef.py b/extreme_fit/function/param_function/abstract_coef.py
index 88a10d74..28dfa230 100644
--- a/extreme_fit/function/param_function/abstract_coef.py
+++ b/extreme_fit/function/param_function/abstract_coef.py
@@ -5,8 +5,8 @@ from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoo
class AbstractCoef(object):
- def __init__(self, gev_param_name: str = '', default_value: float = 0.0, idx_to_coef=None):
- self.gev_param_name = gev_param_name
+ def __init__(self, param_name: str = '', default_value: float = 0.0, idx_to_coef=None):
+ self.param_name = param_name
self.default_value = default_value
self.idx_to_coef = idx_to_coef
@@ -29,11 +29,11 @@ class AbstractCoef(object):
raise NotImplementedError
@classmethod
- def from_coef(cls, coef_dict: Dict[str, float], gev_param_name: str, dims: List[int], coordinates: AbstractCoordinates):
+ def from_coef(cls, coef_dict: Dict[str, float], param_name: str, dims: List[int], coordinates: AbstractCoordinates):
raise NotImplementedError
""" Form dict """
def form_dict(self, names: List[str]) -> Dict[str, str]:
formula_str = '1' if not names else '+'.join(names)
- return {self.gev_param_name + '.form': self.gev_param_name + ' ~ ' + formula_str}
\ No newline at end of file
+ return {self.param_name + '.form': self.param_name + ' ~ ' + formula_str}
\ No newline at end of file
diff --git a/extreme_fit/function/param_function/linear_coef.py b/extreme_fit/function/param_function/linear_coef.py
index 10cdd1c1..5ea2d0cc 100644
--- a/extreme_fit/function/param_function/linear_coef.py
+++ b/extreme_fit/function/param_function/linear_coef.py
@@ -20,20 +20,20 @@ class LinearCoef(AbstractCoef):
return self.get_coef(idx=-1)
@classmethod
- def coef_template_str(cls, gev_param_name: str, coefficient_name: str) -> str:
+ def coef_template_str(cls, param_name: str, coefficient_name: str) -> str:
"""
Example of coef that can be specified
-for the spatial covariates: locCoeff
-for the temporal covariates: tempCoeffLoc
- :param gev_param_name:
+ :param param_name:
:param coefficient_name:
:return:
"""
assert coefficient_name == cls.INTERCEPT_NAME or coefficient_name in AbstractCoordinates.COORDINATES_NAMES
if coefficient_name == cls.INTERCEPT_NAME or coefficient_name in AbstractCoordinates.COORDINATE_SPATIAL_NAMES:
- coef_template_str = gev_param_name + cls.COEFF_STR + '{}'
+ coef_template_str = param_name + cls.COEFF_STR + '{}'
else:
- coef_template_str = 'temp' + cls.COEFF_STR + gev_param_name.title() + '{}'
+ coef_template_str = 'temp' + cls.COEFF_STR + param_name.title() + '{}'
assert cls.COEFF_STR in coef_template_str
return coef_template_str
@@ -49,18 +49,18 @@ class LinearCoef(AbstractCoef):
""" Coef dict """
@classmethod
- def from_coef_dict(cls, coef_dict: Dict[str, float], gev_param_name: str, dims: List[int],
+ def from_coef_dict(cls, coef_dict: Dict[str, float], param_name: str, dims: List[int],
coordinates: AbstractCoordinates):
- idx_to_coef = {-1: coef_dict[cls.coef_template_str(gev_param_name, coefficient_name=cls.INTERCEPT_NAME).format(1)]}
+ idx_to_coef = {-1: coef_dict[cls.coef_template_str(param_name, coefficient_name=cls.INTERCEPT_NAME).format(1)]}
j = 2
for dim in dims:
coefficient_name = coordinates.coordinates_names[dim]
if coefficient_name == AbstractCoordinates.COORDINATE_T:
j = 1
- coef = coef_dict[cls.coef_template_str(gev_param_name, coefficient_name).format(j)]
+ coef = coef_dict[cls.coef_template_str(param_name, coefficient_name).format(j)]
idx_to_coef[dim] = coef
j += 1
- return cls(gev_param_name=gev_param_name, idx_to_coef=idx_to_coef)
+ return cls(param_name=param_name, idx_to_coef=idx_to_coef)
def coef_dict(self, dims, dim_to_coefficient_name: Dict[int, str]) -> Dict[str, float]:
dims = self.add_intercept_idx(dims)
@@ -71,7 +71,7 @@ class LinearCoef(AbstractCoef):
if coefficient_name == AbstractCoordinates.COORDINATE_T:
j = 1
coef = self.idx_to_coef[dim]
- coef_dict[self.coef_template_str(self.gev_param_name, coefficient_name).format(j)] = coef
+ coef_dict[self.coef_template_str(self.param_name, coefficient_name).format(j)] = coef
j += 1
return coef_dict
diff --git a/extreme_fit/function/param_function/spline_coef.py b/extreme_fit/function/param_function/spline_coef.py
index c5983fe6..c506811d 100644
--- a/extreme_fit/function/param_function/spline_coef.py
+++ b/extreme_fit/function/param_function/spline_coef.py
@@ -11,8 +11,8 @@ class PolynomialCoef(AbstractCoef):
degree = 3 correspond to the the coefficient of the first order polynomial
"""
- def __init__(self, gev_param_name: str, default_value: float = 1.0, degree_to_coef=None):
- super().__init__(gev_param_name, default_value, idx_to_coef=degree_to_coef)
+ def __init__(self, param_name: str, default_value: float = 1.0, degree_to_coef=None):
+ super().__init__(param_name, default_value, idx_to_coef=degree_to_coef)
def compute_default_value(self, idx):
return self.default_value / idx
@@ -20,13 +20,13 @@ class PolynomialCoef(AbstractCoef):
class KnotCoef(AbstractCoef):
- def __init__(self, gev_param_name: str, default_value: float = 1.0, idx_to_coef=None):
- super().__init__(gev_param_name, default_value, idx_to_coef)
+ def __init__(self, param_name: str, default_value: float = 1.0, idx_to_coef=None):
+ super().__init__(param_name, default_value, idx_to_coef)
class SplineCoef(AbstractCoef):
- def __init__(self, gev_param_name: str, knot_coef: KnotCoef, dim_to_polynomial_coef: Dict[int, PolynomialCoef]):
- super().__init__(gev_param_name, 1.0, None)
+ def __init__(self, param_name: str, knot_coef: KnotCoef, dim_to_polynomial_coef: Dict[int, PolynomialCoef]):
+ super().__init__(param_name, 1.0, None)
self.knot_coef = knot_coef
self.dim_to_polynomial_coef = dim_to_polynomial_coef
diff --git a/extreme_fit/model/margin_model/linear_margin_model/abstract_temporal_linear_margin_model.py b/extreme_fit/model/margin_model/linear_margin_model/abstract_temporal_linear_margin_model.py
index af2e2533..831ae8a9 100644
--- a/extreme_fit/model/margin_model/linear_margin_model/abstract_temporal_linear_margin_model.py
+++ b/extreme_fit/model/margin_model/linear_margin_model/abstract_temporal_linear_margin_model.py
@@ -60,7 +60,7 @@ class AbstractTemporalLinearMarginModel(LinearMarginModel):
res = safe_run_r_estimator(function=r('gev.fit'), use_start=self.use_start_value,
xdat=x, y=y, mul=self.mul,
sigl=self.sigl, shl=self.shl)
- return ResultFromIsmev(res, self.margin_function_start_fit.gev_param_name_to_dims)
+ return ResultFromIsmev(res, self.margin_function_start_fit.param_name_to_dims)
# Gev fit with extRemes package
@@ -86,7 +86,7 @@ class AbstractTemporalLinearMarginModel(LinearMarginModel):
method=method,
**r_type_argument_kwargs
)
- return ResultFromMleExtremes(res, self.margin_function_start_fit.gev_param_name_to_dims,
+ return ResultFromMleExtremes(res, self.margin_function_start_fit.param_name_to_dims,
type_for_mle=self.type_for_mle)
def extremes_fevd_bayesian_fit(self, x, df_coordinates_temp) -> AbstractResultFromExtremes:
@@ -95,8 +95,8 @@ class AbstractTemporalLinearMarginModel(LinearMarginModel):
r_type_argument_kwargs['initial'] = r.list(**params_start_fit)
# Assert for any non-stationary model that the shape parameter is constant
# (because the prior function considers that the last parameter should be the shape)
- assert GevParams.SHAPE not in self.margin_function_start_fit.gev_param_name_to_dims \
- or len(self.margin_function_start_fit.gev_param_name_to_dims[GevParams.SHAPE]) == 1
+ assert GevParams.SHAPE not in self.margin_function_start_fit.param_name_to_dims \
+ or len(self.margin_function_start_fit.param_name_to_dims[GevParams.SHAPE]) == 1
res = safe_run_r_estimator(function=r('fevd_fixed'),
x=x,
data=y,
@@ -106,7 +106,7 @@ class AbstractTemporalLinearMarginModel(LinearMarginModel):
iter=self.nb_iterations_for_bayesian_fit,
**r_type_argument_kwargs
)
- return ResultFromBayesianExtremes(res, self.margin_function_start_fit.gev_param_name_to_dims)
+ return ResultFromBayesianExtremes(res, self.margin_function_start_fit.param_name_to_dims)
def extreme_arguments(self, df_coordinates_temp):
# Disable the use of log sigma parametrization
diff --git a/extreme_fit/model/margin_model/linear_margin_model/linear_margin_model.py b/extreme_fit/model/margin_model/linear_margin_model/linear_margin_model.py
index 422bb806..68166e99 100644
--- a/extreme_fit/model/margin_model/linear_margin_model/linear_margin_model.py
+++ b/extreme_fit/model/margin_model/linear_margin_model/linear_margin_model.py
@@ -7,15 +7,15 @@ from extreme_fit.distribution.gev.gev_params import GevParams
class LinearMarginModel(ParametricMarginModel):
@classmethod
- def from_coef_list(cls, coordinates, gev_param_name_to_coef_list, params_class=GevParams, **kwargs):
+ def from_coef_list(cls, coordinates, param_name_to_coef_list, params_class=GevParams, **kwargs):
params = {}
- for param_name, coef_list in gev_param_name_to_coef_list.items():
+ for param_name, coef_list in param_name_to_coef_list.items():
for idx, coef in enumerate(coef_list, -1):
params[(param_name, idx)] = coef
return cls(coordinates, params_sample=params, params_start_fit=params, params_class=params_class, **kwargs)
- def load_margin_functions(self, gev_param_name_to_dims=None):
- assert gev_param_name_to_dims is not None, 'LinearMarginModel cannot be used for sampling/fitting \n' \
+ def load_margin_functions(self, param_name_to_dims=None):
+ assert param_name_to_dims is not None, 'LinearMarginModel cannot be used for sampling/fitting \n' \
'load_margin_functions needs to be implemented in child class'
# Load default params (with a dictionary format to enable quick replacement)
# IMPORTANT: Using a dictionary format enable using the default/user params methodology
@@ -23,18 +23,18 @@ class LinearMarginModel(ParametricMarginModel):
self.default_params_start_fit = self.default_param_name_and_dim_to_coef
# Load sample coef
- coef_sample = self.gev_param_name_to_linear_coef(param_name_and_dim_to_coef=self.params_sample)
+ coef_sample = self.param_name_to_linear_coef(param_name_and_dim_to_coef=self.params_sample)
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,
+ param_name_to_coef=coef_sample,
+ param_name_to_dims=param_name_to_dims,
starting_point=self.starting_point,
params_class=self.params_class)
# Load start fit coef
- coef_start_fit = self.gev_param_name_to_linear_coef(param_name_and_dim_to_coef=self.params_start_fit)
+ coef_start_fit = self.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,
+ param_name_to_coef=coef_start_fit,
+ param_name_to_dims=param_name_to_dims,
starting_point=self.starting_point,
params_class=self.params_class)
@@ -42,51 +42,51 @@ class LinearMarginModel(ParametricMarginModel):
def default_param_name_and_dim_to_coef(self) -> dict:
default_intercept = 1
default_slope = 0.01
- gev_param_name_and_dim_to_coef = {}
+ param_name_and_dim_to_coef = {}
for param_name in self.params_class.PARAM_NAMES:
- gev_param_name_and_dim_to_coef[(param_name, -1)] = default_intercept
+ param_name_and_dim_to_coef[(param_name, -1)] = default_intercept
for dim in self.coordinates.coordinates_dims:
- gev_param_name_and_dim_to_coef[(param_name, dim)] = default_slope
- return gev_param_name_and_dim_to_coef
+ param_name_and_dim_to_coef[(param_name, dim)] = default_slope
+ return param_name_and_dim_to_coef
- def gev_param_name_to_linear_coef(self, param_name_and_dim_to_coef):
+ def param_name_to_linear_coef(self, param_name_and_dim_to_coef):
param_name_to_linear_coef = {}
param_names = list(set([e[0] for e in param_name_and_dim_to_coef.keys()]))
for param_name in param_names:
idx_to_coef = {idx: param_name_and_dim_to_coef[(param_name, idx)] for idx in
[-1] + self.coordinates.coordinates_dims}
- linear_coef = LinearCoef(gev_param_name=param_name, idx_to_coef=idx_to_coef)
+ linear_coef = LinearCoef(param_name=param_name, idx_to_coef=idx_to_coef)
param_name_to_linear_coef[param_name] = linear_coef
return param_name_to_linear_coef
class ConstantMarginModel(LinearMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({})
class LinearShapeDim0MarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: [0]})
class LinearScaleDim0MarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SCALE: [0]})
class LinearShapeDim0and1MarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: [0, 1]})
class LinearAllParametersDim0MarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: [0],
GevParams.LOC: [0],
GevParams.SCALE: [0]})
@@ -94,7 +94,7 @@ class LinearAllParametersDim0MarginModel(LinearMarginModel):
class LinearMarginModelExample(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: [0],
GevParams.LOC: [1],
GevParams.SCALE: [0]})
@@ -102,19 +102,19 @@ class LinearMarginModelExample(LinearMarginModel):
class LinearLocationAllDimsMarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.LOC: self.coordinates.coordinates_dims})
class LinearShapeAllDimsMarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: self.coordinates.coordinates_dims})
class LinearAllParametersAllDimsMarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: self.coordinates.coordinates_dims,
GevParams.LOC: self.coordinates.coordinates_dims,
GevParams.SCALE: self.coordinates.coordinates_dims})
@@ -122,7 +122,7 @@ class LinearAllParametersAllDimsMarginModel(LinearMarginModel):
class LinearStationaryMarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: self.coordinates.spatial_coordinates_dims,
GevParams.LOC: self.coordinates.spatial_coordinates_dims,
GevParams.SCALE: self.coordinates.spatial_coordinates_dims})
@@ -130,7 +130,7 @@ class LinearStationaryMarginModel(LinearMarginModel):
class LinearNonStationaryLocationMarginModel(LinearMarginModel):
- def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_dims=None):
+ def load_margin_functions(self, margin_function_class: type = None, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: self.coordinates.spatial_coordinates_dims,
GevParams.LOC: self.coordinates.coordinates_dims,
GevParams.SCALE: self.coordinates.spatial_coordinates_dims})
diff --git a/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_exp_models.py b/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_exp_models.py
index 677f1865..0204a860 100644
--- a/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_exp_models.py
+++ b/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_exp_models.py
@@ -11,5 +11,5 @@ class NonStationaryRateTemporalModel(AbstractTemporalLinearMarginModel, Abstract
super().__init__(*arg, **kwargs)
self.drop_duplicates = False
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({ExpParams.RATE: [self.coordinates.idx_temporal_coordinates]})
diff --git a/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_models.py b/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_models.py
index 4746520c..94c69423 100644
--- a/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_models.py
+++ b/extreme_fit/model/margin_model/linear_margin_model/temporal_linear_margin_models.py
@@ -9,13 +9,13 @@ from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoo
class StationaryTemporalModel(AbstractTemporalLinearMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({})
class NonStationaryLocationTemporalModel(AbstractTemporalLinearMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({GevParams.LOC: [self.coordinates.idx_temporal_coordinates]})
@property
@@ -25,7 +25,7 @@ class NonStationaryLocationTemporalModel(AbstractTemporalLinearMarginModel):
class NonStationaryScaleTemporalModel(AbstractTemporalLinearMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({GevParams.SCALE: [self.coordinates.idx_temporal_coordinates]})
@property
@@ -35,7 +35,7 @@ class NonStationaryScaleTemporalModel(AbstractTemporalLinearMarginModel):
class NonStationaryLogScaleTemporalModel(NonStationaryScaleTemporalModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({GevParams.SCALE: [self.coordinates.idx_temporal_coordinates]})
@property
@@ -45,7 +45,7 @@ class NonStationaryLogScaleTemporalModel(NonStationaryScaleTemporalModel):
class NonStationaryShapeTemporalModel(AbstractTemporalLinearMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({GevParams.SHAPE: [self.coordinates.idx_temporal_coordinates]})
@property
@@ -55,7 +55,7 @@ class NonStationaryShapeTemporalModel(AbstractTemporalLinearMarginModel):
class NonStationaryLocationAndScaleTemporalModel(AbstractTemporalLinearMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims=None):
+ def load_margin_functions(self, param_name_to_dims=None):
super().load_margin_functions({GevParams.LOC: [self.coordinates.idx_temporal_coordinates],
GevParams.SCALE: [self.coordinates.idx_temporal_coordinates]})
diff --git a/extreme_fit/model/margin_model/spline_margin_model.py b/extreme_fit/model/margin_model/spline_margin_model.py
index 20d75800..fe2252d0 100644
--- a/extreme_fit/model/margin_model/spline_margin_model.py
+++ b/extreme_fit/model/margin_model/spline_margin_model.py
@@ -15,54 +15,54 @@ class SplineMarginModel(ParametricMarginModel):
params_sample=None):
super().__init__(coordinates, use_start_value, params_start_fit, params_sample)
- def load_margin_functions(self, gev_param_name_to_dims: Dict[str, List[int]] = None,
- gev_param_name_to_coef: Dict[str, AbstractCoef] = None,
- gev_param_name_to_nb_knots: Dict[str, int] = None,
+ def load_margin_functions(self, param_name_to_dims: Dict[str, List[int]] = None,
+ param_name_to_coef: Dict[str, AbstractCoef] = None,
+ param_name_to_nb_knots: Dict[str, int] = None,
degree=3):
# Default parameters
# todo: for the default parameters: take inspiration from the linear_margin_model
# also implement the class method thing
- if gev_param_name_to_dims is None:
- gev_param_name_to_dims = {gev_param_name: self.coordinates.coordinates_dims
- for gev_param_name in GevParams.PARAM_NAMES}
- if gev_param_name_to_coef is None:
- gev_param_name_to_coef = {}
- for gev_param_name in GevParams.PARAM_NAMES:
- knot_coef = KnotCoef(gev_param_name)
- polynomial_coef = PolynomialCoef(gev_param_name)
+ if param_name_to_dims is None:
+ param_name_to_dims = {param_name: self.coordinates.coordinates_dims
+ for param_name in GevParams.PARAM_NAMES}
+ if param_name_to_coef is None:
+ param_name_to_coef = {}
+ for param_name in GevParams.PARAM_NAMES:
+ knot_coef = KnotCoef(param_name)
+ polynomial_coef = PolynomialCoef(param_name)
dim_to_polynomial_coef = {dim: polynomial_coef for dim in self.coordinates.coordinates_dims}
- spline_coef = SplineCoef(gev_param_name, knot_coef, dim_to_polynomial_coef)
- gev_param_name_to_coef[gev_param_name] = spline_coef
- if gev_param_name_to_nb_knots is None:
- gev_param_name_to_nb_knots = {gev_param_name: 2 for gev_param_name in GevParams.PARAM_NAMES}
+ spline_coef = SplineCoef(param_name, knot_coef, dim_to_polynomial_coef)
+ param_name_to_coef[param_name] = spline_coef
+ if param_name_to_nb_knots is None:
+ param_name_to_nb_knots = {param_name: 2 for param_name in GevParams.PARAM_NAMES}
# Load sample coef
self.margin_function_sample = SplineMarginFunction(coordinates=self.coordinates,
- gev_param_name_to_dims=gev_param_name_to_dims,
- gev_param_name_to_coef=gev_param_name_to_coef,
- gev_param_name_to_nb_knots=gev_param_name_to_nb_knots,
+ param_name_to_dims=param_name_to_dims,
+ param_name_to_coef=param_name_to_coef,
+ param_name_to_nb_knots=param_name_to_nb_knots,
degree=degree)
# Load start fit coef
self.margin_function_start_fit = SplineMarginFunction(coordinates=self.coordinates,
- gev_param_name_to_dims=gev_param_name_to_dims,
- gev_param_name_to_coef=gev_param_name_to_coef,
- gev_param_name_to_nb_knots=gev_param_name_to_nb_knots,
+ param_name_to_dims=param_name_to_dims,
+ param_name_to_coef=param_name_to_coef,
+ param_name_to_nb_knots=param_name_to_nb_knots,
degree=degree)
class ConstantSplineMarginModel(SplineMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims: Dict[str, List[int]] = None,
- gev_param_name_to_coef: Dict[str, AbstractCoef] = None,
- gev_param_name_to_nb_knots: Dict[str, int] = None, degree=3):
- super().load_margin_functions({}, gev_param_name_to_coef, gev_param_name_to_nb_knots,
+ def load_margin_functions(self, param_name_to_dims: Dict[str, List[int]] = None,
+ param_name_to_coef: Dict[str, AbstractCoef] = None,
+ param_name_to_nb_knots: Dict[str, int] = None, degree=3):
+ super().load_margin_functions({}, param_name_to_coef, param_name_to_nb_knots,
degree)
class Degree1SplineMarginModel(SplineMarginModel):
- def load_margin_functions(self, gev_param_name_to_dims: Dict[str, List[int]] = None,
- gev_param_name_to_coef: Dict[str, AbstractCoef] = None,
- gev_param_name_to_nb_knots: Dict[str, int] = None, degree=3):
- super().load_margin_functions(gev_param_name_to_dims, gev_param_name_to_coef, gev_param_name_to_nb_knots,
+ def load_margin_functions(self, param_name_to_dims: Dict[str, List[int]] = None,
+ param_name_to_coef: Dict[str, AbstractCoef] = None,
+ param_name_to_nb_knots: Dict[str, int] = None, degree=3):
+ super().load_margin_functions(param_name_to_dims, param_name_to_coef, param_name_to_nb_knots,
degree=1)
diff --git a/extreme_fit/model/result_from_model_fit/result_from_extremes/abstract_result_from_extremes.py b/extreme_fit/model/result_from_model_fit/result_from_extremes/abstract_result_from_extremes.py
index 763b9070..9211019a 100644
--- a/extreme_fit/model/result_from_model_fit/result_from_extremes/abstract_result_from_extremes.py
+++ b/extreme_fit/model/result_from_model_fit/result_from_extremes/abstract_result_from_extremes.py
@@ -14,9 +14,9 @@ from extreme_fit.model.utils import r
class AbstractResultFromExtremes(AbstractResultFromModelFit):
- def __init__(self, result_from_fit: robjects.ListVector, gev_param_name_to_dim=None) -> None:
+ def __init__(self, result_from_fit: robjects.ListVector, param_name_to_dim=None) -> None:
super().__init__(result_from_fit)
- self.gev_param_name_to_dim = gev_param_name_to_dim
+ self.param_name_to_dim = param_name_to_dim
@property
def summary_name_to_value(self):
@@ -44,7 +44,7 @@ class AbstractResultFromExtremes(AbstractResultFromModelFit):
@property
def is_non_stationary(self):
- return len(self.gev_param_name_to_dim) > 0
+ return len(self.param_name_to_dim) > 0
def load_dataframe_from_r_matrix(self, name):
r_matrix = self.name_to_value[name]
@@ -58,9 +58,9 @@ class AbstractResultFromExtremes(AbstractResultFromModelFit):
'tscale': False,
'type': r.c("return.level")
}
- if self.gev_param_name_to_dim:
- d = {GevParams.greek_letter_from_gev_param_name(gev_param_name) + '1': r.c(transformed_temporal_covariate) for
- gev_param_name in self.gev_param_name_to_dim.keys()}
+ if self.param_name_to_dim:
+ d = {GevParams.greek_letter_from_param_name(param_name) + '1': r.c(transformed_temporal_covariate) for
+ param_name in self.param_name_to_dim.keys()}
kwargs = {
"vals": r.list(**d
)
diff --git a/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_bayesian_extremes.py b/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_bayesian_extremes.py
index 21d30fd4..e2176c23 100644
--- a/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_bayesian_extremes.py
+++ b/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_bayesian_extremes.py
@@ -11,9 +11,9 @@ from extreme_fit.model.utils import r
class ResultFromBayesianExtremes(AbstractResultFromExtremes):
- def __init__(self, result_from_fit: robjects.ListVector, gev_param_name_to_dim=None,
+ def __init__(self, result_from_fit: robjects.ListVector, param_name_to_dim=None,
burn_in_percentage=0.5) -> None:
- super().__init__(result_from_fit, gev_param_name_to_dim)
+ super().__init__(result_from_fit, param_name_to_dim)
self.burn_in_percentage = burn_in_percentage
@property
@@ -51,7 +51,7 @@ class ResultFromBayesianExtremes(AbstractResultFromExtremes):
def get_coef_dict_from_posterior_sample(self, s: pd.Series):
assert len(s) >= 3
values = {i: v for i, v in enumerate(s)}
- return get_margin_coef_ordered_dict(self.gev_param_name_to_dim, values)
+ return get_margin_coef_ordered_dict(self.param_name_to_dim, values)
@property
def margin_coef_ordered_dict(self):
@@ -65,7 +65,7 @@ class ResultFromBayesianExtremes(AbstractResultFromExtremes):
'FUN': "mean",
}
res = r.ci(self.result_from_fit, **bayesian_ci_parameters, **common_kwargs)
- if self.gev_param_name_to_dim:
+ if self.param_name_to_dim:
a = np.array(res)[0]
lower, mean_estimate, upper = a
else:
diff --git a/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_mle_extremes.py b/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_mle_extremes.py
index 14ea112b..4425b7ea 100644
--- a/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_mle_extremes.py
+++ b/extreme_fit/model/result_from_model_fit/result_from_extremes/result_from_mle_extremes.py
@@ -11,9 +11,9 @@ from extreme_fit.model.utils import r
class ResultFromMleExtremes(AbstractResultFromExtremes):
- def __init__(self, result_from_fit: robjects.ListVector, gev_param_name_to_dim=None,
+ def __init__(self, result_from_fit: robjects.ListVector, param_name_to_dim=None,
type_for_mle="GEV") -> None:
- super().__init__(result_from_fit, gev_param_name_to_dim)
+ super().__init__(result_from_fit, param_name_to_dim)
self.type_for_mle = type_for_mle
@property
@@ -24,7 +24,7 @@ class ResultFromMleExtremes(AbstractResultFromExtremes):
values = {i: param for i, param in enumerate(np.array(d['par']))}
else:
values = {i: np.array(v)[0] for i, v in enumerate(d.values())}
- return get_margin_coef_ordered_dict(self.gev_param_name_to_dim, values, self.type_for_mle)
+ return get_margin_coef_ordered_dict(self.param_name_to_dim, values, self.type_for_mle)
def _confidence_interval_method(self, common_kwargs, ci_method, return_period):
method_name = ci_method_to_method_name[ci_method]
diff --git a/extreme_fit/model/result_from_model_fit/result_from_ismev.py b/extreme_fit/model/result_from_model_fit/result_from_ismev.py
index 22eef48d..8db50675 100644
--- a/extreme_fit/model/result_from_model_fit/result_from_ismev.py
+++ b/extreme_fit/model/result_from_model_fit/result_from_ismev.py
@@ -10,13 +10,13 @@ from extreme_fit.model.result_from_model_fit.utils import get_margin_coef_ordere
class ResultFromIsmev(AbstractResultFromModelFit):
- def __init__(self, result_from_fit: robjects.ListVector, gev_param_name_to_dim=None) -> None:
+ def __init__(self, result_from_fit: robjects.ListVector, param_name_to_dim=None) -> None:
super().__init__(result_from_fit)
- self.gev_param_name_to_dim = gev_param_name_to_dim
+ self.param_name_to_dim = param_name_to_dim
@property
def margin_coef_ordered_dict(self):
- return get_margin_coef_ordered_dict(self.gev_param_name_to_dim, self.name_to_value['mle'])
+ return get_margin_coef_ordered_dict(self.param_name_to_dim, self.name_to_value['mle'])
@property
def all_parameters(self):
diff --git a/extreme_fit/model/result_from_model_fit/utils.py b/extreme_fit/model/result_from_model_fit/utils.py
index 1bb34aae..020a3b82 100644
--- a/extreme_fit/model/result_from_model_fit/utils.py
+++ b/extreme_fit/model/result_from_model_fit/utils.py
@@ -11,23 +11,23 @@ def convertFloatVector_to_float(f):
return np.array(f)[0]
-def get_margin_coef_ordered_dict(gev_param_name_to_dim, mle_values, type_for_mle="GEV"):
- assert gev_param_name_to_dim is not None
- # Build the Coeff dict from gev_param_name_to_dim
+def get_margin_coef_ordered_dict(param_name_to_dim, mle_values, type_for_mle="GEV"):
+ assert param_name_to_dim is not None
+ # Build the Coeff dict from param_name_to_dim
coef_dict = OrderedDict()
i = 0
- for gev_param_name in GevParams.PARAM_NAMES:
+ for param_name in GevParams.PARAM_NAMES:
# Add intercept (i.e. stationary parameter)
- intercept_coef_name = LinearCoef.coef_template_str(gev_param_name, LinearCoef.INTERCEPT_NAME).format(1)
- if type_for_mle == "Gumbel" and gev_param_name == GevParams.SHAPE:
+ intercept_coef_name = LinearCoef.coef_template_str(param_name, LinearCoef.INTERCEPT_NAME).format(1)
+ if type_for_mle == "Gumbel" and param_name == GevParams.SHAPE:
coef_value = 0
else:
coef_value = mle_values[i]
coef_dict[intercept_coef_name] = coef_value
i += 1
# Add a potential linear temporal trend
- if gev_param_name in gev_param_name_to_dim:
- temporal_coef_name = LinearCoef.coef_template_str(gev_param_name,
+ if param_name in param_name_to_dim:
+ temporal_coef_name = LinearCoef.coef_template_str(param_name,
AbstractCoordinates.COORDINATE_T).format(1)
coef_dict[temporal_coef_name] = mle_values[i]
i += 1
diff --git a/extreme_trend/abstract_gev_trend_test.py b/extreme_trend/abstract_gev_trend_test.py
index d9786929..5cbfa164 100644
--- a/extreme_trend/abstract_gev_trend_test.py
+++ b/extreme_trend/abstract_gev_trend_test.py
@@ -106,8 +106,8 @@ class AbstractGevTrendTest(object):
def test_sign(self) -> int:
return np.sign(self.time_derivative_of_return_level)
- def get_non_stationary_linear_coef(self, gev_param_name: str):
- return self.unconstrained_estimator.function_from_fit.get_coef(gev_param_name,
+ def get_non_stationary_linear_coef(self, param_name: str):
+ return self.unconstrained_estimator.function_from_fit.get_coef(param_name,
AbstractCoordinates.COORDINATE_T)
@cached_property
diff --git a/extreme_trend/trend_test_one_parameter/gev_trend_test_one_parameter.py b/extreme_trend/trend_test_one_parameter/gev_trend_test_one_parameter.py
index c2371186..e23df337 100644
--- a/extreme_trend/trend_test_one_parameter/gev_trend_test_one_parameter.py
+++ b/extreme_trend/trend_test_one_parameter/gev_trend_test_one_parameter.py
@@ -17,7 +17,7 @@ class GevTrendTestOneParameter(AbstractGevTrendTest):
class GevTrendTestOneParameterAgainstStationary(GevTrendTestOneParameter):
- def __init__(self, years, maxima, starting_year, unconstrained_model_class, gev_param_name,
+ def __init__(self, years, maxima, starting_year, unconstrained_model_class, param_name,
quantile_level=EUROCODE_QUANTILE,
constrained_model_class=StationaryTemporalModel,
fit_method=MarginFitMethod.extremes_fevd_mle):
@@ -26,11 +26,11 @@ class GevTrendTestOneParameterAgainstStationary(GevTrendTestOneParameter):
quantile_level=quantile_level,
constrained_model_class=constrained_model_class,
fit_method=fit_method)
- self.gev_param_name = gev_param_name
+ self.param_name = param_name
@property
def non_stationary_linear_coef(self):
- return self.get_non_stationary_linear_coef(gev_param_name=self.gev_param_name)
+ return self.get_non_stationary_linear_coef(param_name=self.param_name)
class GevLocationTrendTest(GevTrendTestOneParameterAgainstStationary):
@@ -40,7 +40,7 @@ class GevLocationTrendTest(GevTrendTestOneParameterAgainstStationary):
super().__init__(years, maxima, starting_year,
unconstrained_model_class=NonStationaryLocationTemporalModel,
constrained_model_class=constrained_model_class,
- gev_param_name=GevParams.LOC,
+ param_name=GevParams.LOC,
quantile_level=quantile_level,
fit_method=fit_method)
@@ -65,7 +65,7 @@ class GevScaleTrendTest(GevTrendTestOneParameterAgainstStationary):
super().__init__(years, maxima, starting_year,
unconstrained_model_class=NonStationaryScaleTemporalModel,
constrained_model_class=constrained_model_class,
- gev_param_name=GevParams.SCALE,
+ param_name=GevParams.SCALE,
quantile_level=quantile_level,
fit_method=fit_method)
@@ -91,7 +91,7 @@ class GevShapeTrendTest(GevTrendTestOneParameterAgainstStationary):
def __init__(self, years, maxima, starting_year, quantile_level=EUROCODE_QUANTILE, fit_method=MarginFitMethod.extremes_fevd_mle):
super().__init__(years, maxima, starting_year,
unconstrained_model_class=NonStationaryShapeTemporalModel,
- gev_param_name=GevParams.SHAPE,
+ param_name=GevParams.SHAPE,
quantile_level=quantile_level,
fit_method=fit_method)
diff --git a/extreme_trend/trend_test_one_parameter/gumbel_trend_test_one_parameter.py b/extreme_trend/trend_test_one_parameter/gumbel_trend_test_one_parameter.py
index e3028a00..79e8f494 100644
--- a/extreme_trend/trend_test_one_parameter/gumbel_trend_test_one_parameter.py
+++ b/extreme_trend/trend_test_one_parameter/gumbel_trend_test_one_parameter.py
@@ -70,7 +70,7 @@ class GumbelLocationTrendTest(GevTrendTestOneParameterAgainstStationary):
def __init__(self, years, maxima, starting_year, quantile_level=EUROCODE_QUANTILE, fit_method=MarginFitMethod.extremes_fevd_mle):
super().__init__(years, maxima, starting_year,
unconstrained_model_class=NonStationaryLocationGumbelModel,
- gev_param_name=GevParams.LOC,
+ param_name=GevParams.LOC,
quantile_level=quantile_level,
constrained_model_class=GumbelTemporalModel, fit_method=fit_method)
@@ -97,7 +97,7 @@ class GumbelScaleTrendTest(GevTrendTestOneParameterAgainstStationary):
fit_method=MarginFitMethod.extremes_fevd_mle):
super().__init__(years, maxima, starting_year,
unconstrained_model_class=NonStationaryScaleGumbelModel,
- gev_param_name=GevParams.SCALE,
+ param_name=GevParams.SCALE,
quantile_level=quantile_level,
constrained_model_class=GumbelTemporalModel,
fit_method=fit_method)
diff --git a/extreme_trend/trend_test_three_parameters/gev_trend_test_three_parameters.py b/extreme_trend/trend_test_three_parameters/gev_trend_test_three_parameters.py
index 793c7ea3..e69fd8a4 100644
--- a/extreme_trend/trend_test_three_parameters/gev_trend_test_three_parameters.py
+++ b/extreme_trend/trend_test_three_parameters/gev_trend_test_three_parameters.py
@@ -26,11 +26,11 @@ class GevLocationAndScaleTrendTestAgainstGumbel(GevTrendTestThreeParameters):
@property
def mu1(self):
- return self.get_non_stationary_linear_coef(gev_param_name=GevParams.LOC)
+ return self.get_non_stationary_linear_coef(param_name=GevParams.LOC)
@property
def sigma1(self):
- return self.get_non_stationary_linear_coef(gev_param_name=GevParams.SCALE)
+ return self.get_non_stationary_linear_coef(param_name=GevParams.SCALE)
def _slope_strength(self):
return self.unconstrained_estimator_gev_params.time_derivative_of_return_level(p=self.quantile_level,
diff --git a/extreme_trend/trend_test_two_parameters/gev_trend_test_two_parameters.py b/extreme_trend/trend_test_two_parameters/gev_trend_test_two_parameters.py
index 21d596e8..ae6b8f54 100644
--- a/extreme_trend/trend_test_two_parameters/gev_trend_test_two_parameters.py
+++ b/extreme_trend/trend_test_two_parameters/gev_trend_test_two_parameters.py
@@ -29,11 +29,11 @@ class GevLocationAndScaleTrendTest(GevTrendTestTwoParameters):
@property
def mu1(self):
- return self.get_non_stationary_linear_coef(gev_param_name=GevParams.LOC)
+ return self.get_non_stationary_linear_coef(param_name=GevParams.LOC)
@property
def sigma1(self):
- return self.get_non_stationary_linear_coef(gev_param_name=GevParams.SCALE)
+ return self.get_non_stationary_linear_coef(param_name=GevParams.SCALE)
def _slope_strength(self):
return self.unconstrained_estimator_gev_params.time_derivative_of_return_level(p=self.quantile_level,
diff --git a/extreme_trend/trend_test_two_parameters/gumbel_test_two_parameters.py b/extreme_trend/trend_test_two_parameters/gumbel_test_two_parameters.py
index 812f259f..db57fb57 100644
--- a/extreme_trend/trend_test_two_parameters/gumbel_test_two_parameters.py
+++ b/extreme_trend/trend_test_two_parameters/gumbel_test_two_parameters.py
@@ -24,11 +24,11 @@ class GumbelLocationAndScaleTrendTest(GevTrendTestTwoParameters):
@property
def mu1(self):
- return self.get_non_stationary_linear_coef(gev_param_name=GevParams.LOC)
+ return self.get_non_stationary_linear_coef(param_name=GevParams.LOC)
@property
def sigma1(self):
- return self.get_non_stationary_linear_coef(gev_param_name=GevParams.SCALE)
+ return self.get_non_stationary_linear_coef(param_name=GevParams.SCALE)
def _slope_strength(self):
return self.unconstrained_estimator_gev_params.time_derivative_of_return_level(p=self.quantile_level,
diff --git a/projects/contrasting_trends_in_snow_loads/check_mcmc_convergence_for_return_levels/main_bayesian_mcmc.py b/projects/contrasting_trends_in_snow_loads/check_mcmc_convergence_for_return_levels/main_bayesian_mcmc.py
index 969b8bae..81818b43 100644
--- a/projects/contrasting_trends_in_snow_loads/check_mcmc_convergence_for_return_levels/main_bayesian_mcmc.py
+++ b/projects/contrasting_trends_in_snow_loads/check_mcmc_convergence_for_return_levels/main_bayesian_mcmc.py
@@ -47,15 +47,15 @@ def plot_chain(N=10000, show=True):
lns = []
# Last color is for the return level
colors = ['r', 'g', 'b', 'tab:orange']
- gev_param_name_to_color = dict(zip(GevParams.PARAM_NAMES, colors))
- gev_param_name_to_ax = dict(
+ param_name_to_color = dict(zip(GevParams.PARAM_NAMES, colors))
+ param_name_to_ax = dict(
zip(GevParams.PARAM_NAMES, [ax_trajectories, ax_trajectories, ax_trajectories]))
# zip(GevParams.PARAM_NAMES, [ax_trajectories, ax_trajectories, ax_trajectories_inverted]))
- gev_param_name_to_label = {n: GevParams.greek_letter_from_gev_param_name(n) for n in GevParams.PARAM_NAMES}
- for j, gev_param_name in enumerate(GevParams.PARAM_NAMES[:]):
- label = gev_param_name_to_label[gev_param_name]
- ax = gev_param_name_to_ax[gev_param_name]
- color = gev_param_name_to_color[gev_param_name]
+ param_name_to_label = {n: GevParams.greek_letter_from_param_name(n) for n in GevParams.PARAM_NAMES}
+ for j, param_name in enumerate(GevParams.PARAM_NAMES[:]):
+ label = param_name_to_label[param_name]
+ ax = param_name_to_ax[param_name]
+ color = param_name_to_color[param_name]
ln = ax.plot(iteration_step, df_all_samples.iloc[:, j].values, label=label, color=color)
lns.extend(ln)
ax_trajectories_inverted.set_ylim(-0.3, 10)
@@ -71,15 +71,15 @@ def plot_chain(N=10000, show=True):
# Plot the parameter posterior on axes 1
ax_parameter_posterior = axes[1]
ax_parameter_posterior_flip = ax_parameter_posterior.twiny()
- gev_param_name_to_ax = dict(
+ param_name_to_ax = dict(
zip(GevParams.PARAM_NAMES,
[ax_parameter_posterior, ax_parameter_posterior.twiny(), ax_parameter_posterior_flip]))
df_posterior_samples = return_level_bayesian.result_from_fit.df_posterior_samples
lns = []
- for j, gev_param_name in enumerate(GevParams.PARAM_NAMES[:]):
- label = gev_param_name_to_label[gev_param_name]
- color = gev_param_name_to_color[gev_param_name]
- ax = gev_param_name_to_ax[gev_param_name]
+ for j, param_name in enumerate(GevParams.PARAM_NAMES[:]):
+ label = param_name_to_label[param_name]
+ color = param_name_to_color[param_name]
+ ax = param_name_to_ax[param_name]
ln = sns.kdeplot(df_posterior_samples.iloc[:, j], ax=ax, label=label, color=color)
lns.append(ln)
labs = [l.get_label() for l in lns]
diff --git a/projects/quantile_regression_vs_evt/annual_maxima_simulation/daily_exp_simulation.py b/projects/quantile_regression_vs_evt/annual_maxima_simulation/daily_exp_simulation.py
index 3f02d4fe..5c2a76f8 100644
--- a/projects/quantile_regression_vs_evt/annual_maxima_simulation/daily_exp_simulation.py
+++ b/projects/quantile_regression_vs_evt/annual_maxima_simulation/daily_exp_simulation.py
@@ -41,10 +41,10 @@ class AbstractDailyExpSimulation(AnnualMaximaSimulation, ABC):
class StationaryExpSimulation(AbstractDailyExpSimulation):
def create_model(self, coordinates):
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
AbstractParams.RATE: [10],
}
- return StationaryTemporalModel.from_coef_list(coordinates, gev_param_name_to_coef_list,
+ return StationaryTemporalModel.from_coef_list(coordinates, param_name_to_coef_list,
fit_method=MarginFitMethod.extremes_fevd_mle,
params_class=ExpParams)
@@ -52,9 +52,9 @@ class StationaryExpSimulation(AbstractDailyExpSimulation):
class NonStationaryExpSimulation(AbstractDailyExpSimulation):
def create_model(self, coordinates):
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
AbstractParams.RATE: [0.1, 0.01],
}
- return NonStationaryRateTemporalModel.from_coef_list(coordinates, gev_param_name_to_coef_list,
+ return NonStationaryRateTemporalModel.from_coef_list(coordinates, param_name_to_coef_list,
fit_method=MarginFitMethod.extremes_fevd_mle,
params_class=ExpParams)
diff --git a/projects/quantile_regression_vs_evt/annual_maxima_simulation/gev_simulation.py b/projects/quantile_regression_vs_evt/annual_maxima_simulation/gev_simulation.py
index 07a79aa9..72864322 100644
--- a/projects/quantile_regression_vs_evt/annual_maxima_simulation/gev_simulation.py
+++ b/projects/quantile_regression_vs_evt/annual_maxima_simulation/gev_simulation.py
@@ -30,34 +30,34 @@ class GevSimulation(AnnualMaximaSimulation):
class StationarySimulation(GevSimulation):
def create_model(self, coordinates):
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
GevParams.LOC: [0],
GevParams.SHAPE: [0],
GevParams.SCALE: [1],
}
- return StationaryTemporalModel.from_coef_list(coordinates, gev_param_name_to_coef_list,
+ return StationaryTemporalModel.from_coef_list(coordinates, param_name_to_coef_list,
fit_method=MarginFitMethod.extremes_fevd_mle)
class NonStationaryLocationGumbelSimulation(GevSimulation):
def create_model(self, coordinates):
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
GevParams.LOC: [0, 10],
GevParams.SHAPE: [0],
GevParams.SCALE: [1],
}
- return NonStationaryLocationTemporalModel.from_coef_list(coordinates, gev_param_name_to_coef_list,
+ return NonStationaryLocationTemporalModel.from_coef_list(coordinates, param_name_to_coef_list,
fit_method=MarginFitMethod.extremes_fevd_mle)
class NonStationaryLocationGevSimulation(GevSimulation):
def create_model(self, coordinates):
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
GevParams.LOC: [0, 1],
GevParams.SHAPE: [0.3],
GevParams.SCALE: [1],
}
- return NonStationaryLocationTemporalModel.from_coef_list(coordinates, gev_param_name_to_coef_list,
+ return NonStationaryLocationTemporalModel.from_coef_list(coordinates, param_name_to_coef_list,
fit_method=MarginFitMethod.extremes_fevd_mle)
diff --git a/test/test_extreme_fit/test_function/test_margin_function.py b/test/test_extreme_fit/test_function/test_margin_function.py
index fb586df7..10f83b7b 100644
--- a/test/test_extreme_fit/test_function/test_margin_function.py
+++ b/test/test_extreme_fit/test_function/test_margin_function.py
@@ -30,8 +30,8 @@ class MarginFunction(unittest.TestCase):
'tempCoeffLoc1': 1, 'tempCoeffScale1': 1,
'tempCoeffShape1': 1}
margin_function = self.margin_function_class.from_coef_dict(coordinates,
- margin_model.margin_function_sample.gev_param_name_to_dims,
- coef_dict)
+ margin_model.margin_function_sample.param_name_to_dims,
+ coef_dict)
gev_param = margin_function.get_params(coordinate=np.array([0.5, 1.0]), is_transformed=False)
self.assertEqual({'loc': 2, 'scale': 2, 'shape': 2}, gev_param.to_dict())
@@ -44,7 +44,7 @@ class MarginFunction(unittest.TestCase):
'scaleCoeff2': 1, 'shapeCoeff1': 0,
'shapeCoeff2': 1}
margin_function = self.margin_function_class.from_coef_dict(coordinates,
- margin_model.margin_function_sample.gev_param_name_to_dims,
+ margin_model.margin_function_sample.param_name_to_dims,
coef_dict)
gev_param = margin_function.get_params(coordinate=np.array([1]), is_transformed=False)
self.assertEqual({'loc': 3, 'scale': 1, 'shape': 1}, gev_param.to_dict())
diff --git a/test/test_spatio_temporal_dataset/test_spatio_temporal_observations.py b/test/test_spatio_temporal_dataset/test_spatio_temporal_observations.py
index e3285a30..a484b7ab 100644
--- a/test/test_spatio_temporal_dataset/test_spatio_temporal_observations.py
+++ b/test/test_spatio_temporal_dataset/test_spatio_temporal_observations.py
@@ -55,10 +55,10 @@ class TestDailyObservations(unittest.TestCase):
super().setUp()
set_seed_for_test(seed=42)
self.coordinates = ConsecutiveTemporalCoordinates.from_nb_temporal_steps(nb_temporal_steps=10)
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
AbstractParams.RATE: [1],
}
- self.margin_model = StationaryTemporalModel.from_coef_list(self.coordinates, gev_param_name_to_coef_list,
+ self.margin_model = StationaryTemporalModel.from_coef_list(self.coordinates, param_name_to_coef_list,
params_class=ExpParams)
def test_instance_exp_params(self):
diff --git a/test/test_unitary_r_packages/test_spatial_extreme/test_rmaxstab/test_rmaxstab_with_margin.py b/test/test_unitary_r_packages/test_spatial_extreme/test_rmaxstab/test_rmaxstab_with_margin.py
index df02dd5a..8d80948d 100644
--- a/test/test_unitary_r_packages/test_spatial_extreme/test_rmaxstab/test_rmaxstab_with_margin.py
+++ b/test/test_unitary_r_packages/test_spatial_extreme/test_rmaxstab/test_rmaxstab_with_margin.py
@@ -30,12 +30,12 @@ class TestRMaxStabWithMarginConstant(TestUnitaryAbstract):
def python_code(cls):
coordinates, max_stable_model = TestRMaxStab.python_code()
# Load margin model
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
GevParams.LOC: [0.2],
GevParams.SHAPE: [0.2],
GevParams.SCALE: [0.2],
}
- margin_model = ConstantMarginModel.from_coef_list(coordinates, gev_param_name_to_coef_list)
+ margin_model = ConstantMarginModel.from_coef_list(coordinates, param_name_to_coef_list)
# Load dataset
dataset = FullSimulatedDataset.from_double_sampling(nb_obs=40, margin_model=margin_model,
coordinates=coordinates,
@@ -76,12 +76,12 @@ class TestRMaxStabWithLinearMargin(TestUnitaryAbstract):
def python_code(cls):
coordinates, max_stable_model = TestRMaxStab.python_code()
# Load margin model
- gev_param_name_to_coef_list = {
+ param_name_to_coef_list = {
GevParams.LOC: [-10, 0, 2],
GevParams.SHAPE: [2, -3, 0],
GevParams.SCALE: [5, 2, 1],
}
- margin_model = LinearAllParametersAllDimsMarginModel.from_coef_list(coordinates, gev_param_name_to_coef_list)
+ margin_model = LinearAllParametersAllDimsMarginModel.from_coef_list(coordinates, param_name_to_coef_list)
# Load dataset
dataset = FullSimulatedDataset.from_double_sampling(nb_obs=40, margin_model=margin_model,
coordinates=coordinates,
--
GitLab