diff --git a/experiment/regression_margin/regression_margin.py b/experiment/regression_margin/regression_margin.py
index 86fb73f22b0ba1ba33dfad41231e509fbe5a2a86..e4f0e6eae8d654b5424087ab98e2f00ee9fabcdf 100644
--- a/experiment/regression_margin/regression_margin.py
+++ b/experiment/regression_margin/regression_margin.py
@@ -5,7 +5,7 @@ from extreme_estimator.extreme_models.margin_model.margin_function.linear_margin
from extreme_estimator.extreme_models.margin_model.smooth_margin_model import LinearAllParametersAllDimsMarginModel, \
ConstantMarginModel
from extreme_estimator.extreme_models.max_stable_model.max_stable_models import Smith
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import LinSpaceSpatialCoordinates
import matplotlib.pyplot as plt
@@ -23,9 +23,9 @@ coordinates = LinSpaceSpatialCoordinates.from_nb_points(nb_points=nb_points)
# MarginModel Linear with respect to the shape (from 0.01 to 0.02)
params_sample = {
# (GevParams.GEV_SHAPE, 0): 0.2,
- (GevParams.GEV_LOC, 0): 10,
- (GevParams.GEV_SHAPE, 0): 1.0,
- (GevParams.GEV_SCALE, 0): 1.0,
+ (GevParams.LOC, 0): 10,
+ (GevParams.SHAPE, 0): 1.0,
+ (GevParams.SCALE, 0): 1.0,
}
margin_model = ConstantMarginModel(coordinates=coordinates, params_sample=params_sample)
margin_model_for_estimator_class = [LinearAllParametersAllDimsMarginModel, ConstantMarginModel][-1]
@@ -44,7 +44,7 @@ for i in range(nb_estimator):
max_stable_model=max_stable_model)
if show and i == 0:
- # Plot a realization from the maxima gev (i.e the maxima obtained just by simulating the marginal law)
+ # Plot a realization from the maxima margin_fits (i.e the maxima obtained just by simulating the marginal law)
for maxima in np.transpose(dataset.maxima_frech()):
plt.plot(coordinates.coordinates_values(), maxima, 'o')
plt.show()
diff --git a/experiment/simulation/abstract_simulation.py b/experiment/simulation/abstract_simulation.py
index ecdc90113570956c651f4ca284f54d9c0ee933b7..49973ae56631d93a1335d438dd9a574c6ed20220 100644
--- a/experiment/simulation/abstract_simulation.py
+++ b/experiment/simulation/abstract_simulation.py
@@ -2,10 +2,8 @@ import os
from typing import List
import matplotlib
-import matplotlib.pyplot as plt
import matplotlib.colors as colors
import matplotlib.cm as cmx
-import numpy as np
import os.path as op
import pickle
@@ -21,7 +19,7 @@ from extreme_estimator.extreme_models.margin_model.margin_function.abstract_marg
from extreme_estimator.extreme_models.margin_model.margin_function.combined_margin_function import \
CombinedMarginFunction
from extreme_estimator.extreme_models.margin_model.margin_function.utils import error_dict_between_margin_functions
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.dataset.abstract_dataset import get_subset_dataset
from spatio_temporal_dataset.dataset.simulation_dataset import SimulatedDataset
from spatio_temporal_dataset.slicer.split import split_to_display_kwargs
@@ -129,14 +127,14 @@ class AbstractSimulation(object):
@staticmethod
def load_fig_and_axes():
- fig, axes = plt.subplots(len(GevParams.GEV_VALUE_NAMES), 2)
+ fig, axes = plt.subplots(len(GevParams.SUMMARY_NAMES), 2)
fig.subplots_adjust(hspace=0.4, wspace=0.4)
return fig, axes
def visualize(self, fig=None, axes=None, show=True):
if fig is None or axes is None:
fig, axes = self.load_fig_and_axes()
- for i, gev_value_name in enumerate(GevParams.GEV_VALUE_NAMES):
+ for i, gev_value_name in enumerate(GevParams.SUMMARY_NAMES):
self.margin_graph(axes[i, 0], gev_value_name)
self.score_graph(axes[i, 1], gev_value_name)
if show:
diff --git a/experiment/simulation/lin_space2_simulation.py b/experiment/simulation/lin_space2_simulation.py
index d4c0a01141b5be0f96c07a7ac86cc26317262a45..b3ab8757d6c84fb7165e063f61a903d5746f383c 100644
--- a/experiment/simulation/lin_space2_simulation.py
+++ b/experiment/simulation/lin_space2_simulation.py
@@ -4,7 +4,7 @@ from extreme_estimator.estimator.margin_estimator.margin_estimator_for_simulatio
MARGIN_ESTIMATORS_FOR_SIMULATION
from extreme_estimator.extreme_models.margin_model.smooth_margin_model import ConstantMarginModel
from extreme_estimator.extreme_models.max_stable_model.max_stable_models import Smith
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import LinSpaceSpatialCoordinates
from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
@@ -22,9 +22,9 @@ class LinSpace5Simulation(AbstractSimulation):
train_split_ratio=0.75)
# MarginModel Constant for simulation
params_sample = {
- (GevParams.GEV_LOC, 0): 1.0,
- (GevParams.GEV_SHAPE, 0): 1.0,
- (GevParams.GEV_SCALE, 0): 1.0,
+ (GevParams.LOC, 0): 1.0,
+ (GevParams.SHAPE, 0): 1.0,
+ (GevParams.SCALE, 0): 1.0,
}
self.margin_model = ConstantMarginModel(coordinates=self.coordinates,
params_sample=params_sample)
diff --git a/experiment/simulation/lin_space_simulation.py b/experiment/simulation/lin_space_simulation.py
index 3d11e2dd9b6c1f48487291129de322507266c735..96e3618c4198895bfe32323868bc1dc6dd8b93bf 100644
--- a/experiment/simulation/lin_space_simulation.py
+++ b/experiment/simulation/lin_space_simulation.py
@@ -1,10 +1,7 @@
from experiment.simulation.abstract_simulation import AbstractSimulation
-from extreme_estimator.estimator.full_estimator.full_estimator_for_simulation import FULL_ESTIMATORS_FOR_SIMULATION
-from extreme_estimator.estimator.margin_estimator.margin_estimator_for_simulation import \
- MARGIN_ESTIMATORS_FOR_SIMULATION
from extreme_estimator.extreme_models.margin_model.smooth_margin_model import ConstantMarginModel
from extreme_estimator.extreme_models.max_stable_model.max_stable_models import Smith
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.spatial_coordinates.coordinates_1D import LinSpaceSpatialCoordinates
from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
@@ -19,9 +16,9 @@ class LinSpaceSimulation(AbstractSimulation):
self.coordinates = LinSpaceSpatialCoordinates.from_nb_points(nb_points=21, train_split_ratio=0.75)
# MarginModel Linear with respect to the shape (from 0.01 to 0.02)
params_sample = {
- (GevParams.GEV_LOC, 0): 10,
- (GevParams.GEV_SHAPE, 0): 1.0,
- (GevParams.GEV_SCALE, 0): 1.0,
+ (GevParams.LOC, 0): 10,
+ (GevParams.SHAPE, 0): 1.0,
+ (GevParams.SCALE, 0): 1.0,
}
self.margin_model = ConstantMarginModel(coordinates=self.coordinates, params_sample=params_sample)
self.max_stable_model = Smith()
diff --git a/extreme_estimator/extreme_models/margin_model/abstract_margin_model.py b/extreme_estimator/extreme_models/margin_model/abstract_margin_model.py
index ab8742b9ee0ebf6a24daaccad6f69c3576a4acde..df51314ac37f5765a73a2c4b0269dbcb63512b71 100644
--- a/extreme_estimator/extreme_models/margin_model/abstract_margin_model.py
+++ b/extreme_estimator/extreme_models/margin_model/abstract_margin_model.py
@@ -5,7 +5,7 @@ from extreme_estimator.extreme_models.abstract_model import AbstractModel
from extreme_estimator.extreme_models.margin_model.margin_function.abstract_margin_function \
import AbstractMarginFunction
from extreme_estimator.extreme_models.utils import r
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
diff --git a/extreme_estimator/extreme_models/margin_model/margin_function/abstract_margin_function.py b/extreme_estimator/extreme_models/margin_model/margin_function/abstract_margin_function.py
index be5104374aa5fb0b31e3e4aafe2f06bd4a8d06bf..85f1e7dbdcce0a4225d079ffad23f017ff249576 100644
--- a/extreme_estimator/extreme_models/margin_model/margin_function/abstract_margin_function.py
+++ b/extreme_estimator/extreme_models/margin_model/margin_function/abstract_margin_function.py
@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
from spatio_temporal_dataset.slicer.split import Split
@@ -36,10 +36,10 @@ class AbstractMarginFunction(object):
def gev_value_name_to_serie(self) -> Dict[str, pd.Series]:
# Load the gev_params
gev_params = [self.get_gev_params(coordinate) for coordinate in self.coordinates.coordinates_values()]
- # Load the dictionary of values (gev parameters + the quantiles)
- value_dicts = [gev_param.value_dict for gev_param in gev_params]
+ # Load the dictionary of values (margin_fits parameters + the quantiles)
+ value_dicts = [gev_param.summary_dict for gev_param in gev_params]
gev_value_name_to_serie = {}
- for value_name in GevParams.GEV_VALUE_NAMES:
+ for value_name in GevParams.SUMMARY_NAMES:
s = pd.Series(data=[d[value_name] for d in value_dicts], index=self.coordinates.index)
gev_value_name_to_serie[value_name] = s
return gev_value_name_to_serie
@@ -58,10 +58,10 @@ class AbstractMarginFunction(object):
def visualize(self, axes=None, show=True, dot_display=False):
self.datapoint_display = dot_display
if axes is None:
- fig, axes = plt.subplots(1, len(GevParams.GEV_VALUE_NAMES))
+ fig, axes = plt.subplots(1, len(GevParams.SUMMARY_NAMES))
fig.subplots_adjust(hspace=1.0, wspace=1.0)
self.visualization_axes = axes
- for i, gev_value_name in enumerate(GevParams.GEV_VALUE_NAMES):
+ for i, gev_value_name in enumerate(GevParams.SUMMARY_NAMES):
ax = axes[i]
self.visualize_single_param(gev_value_name, ax, show=False)
title_str = gev_value_name
@@ -69,8 +69,8 @@ class AbstractMarginFunction(object):
if show:
plt.show()
- def visualize_single_param(self, gev_value_name=GevParams.GEV_LOC, ax=None, show=True):
- assert gev_value_name in GevParams.GEV_VALUE_NAMES
+ def visualize_single_param(self, gev_value_name=GevParams.LOC, ax=None, show=True):
+ assert gev_value_name in GevParams.SUMMARY_NAMES
if self.coordinates.nb_coordinates_spatial == 1:
self.visualize_1D(gev_value_name, ax, show)
elif self.coordinates.nb_coordinates_spatial == 2:
@@ -80,7 +80,7 @@ class AbstractMarginFunction(object):
# Visualization 1D
- def visualize_1D(self, gev_value_name=GevParams.GEV_LOC, ax=None, show=True):
+ def visualize_1D(self, gev_value_name=GevParams.LOC, ax=None, show=True):
x = self.coordinates.x_coordinates
grid, linspace = self.grid_1D(x)
if ax is None:
@@ -118,13 +118,13 @@ class AbstractMarginFunction(object):
grid = []
for i, xi in enumerate(linspace):
gev_param = self.get_gev_params(np.array([xi]))
- grid.append(gev_param.value_dict)
- grid = {gev_param: [g[gev_param] for g in grid] for gev_param in GevParams.GEV_VALUE_NAMES}
+ grid.append(gev_param.summary_dict)
+ grid = {gev_param: [g[gev_param] for g in grid] for gev_param in GevParams.SUMMARY_NAMES}
return grid, linspace
# Visualization 2D
- def visualize_2D(self, gev_value_name=GevParams.GEV_LOC, ax=None, show=True):
+ def visualize_2D(self, gev_value_name=GevParams.LOC, ax=None, show=True):
x = self.coordinates.x_coordinates
y = self.coordinates.y_coordinates
grid = self.grid_2D(x, y)
@@ -155,7 +155,7 @@ class AbstractMarginFunction(object):
grid = []
for i, xi in enumerate(np.linspace(x.min(), x.max(), resolution)):
for j, yj in enumerate(np.linspace(y.min(), y.max(), resolution)):
- grid.append(self.get_gev_params(np.array([xi, yj])).value_dict)
+ grid.append(self.get_gev_params(np.array([xi, yj])).summary_dict)
grid = {value_name: np.array([g[value_name] for g in grid]).reshape([resolution, resolution])
- for value_name in GevParams.GEV_VALUE_NAMES}
+ for value_name in GevParams.SUMMARY_NAMES}
return grid
diff --git a/extreme_estimator/extreme_models/margin_model/margin_function/combined_margin_function.py b/extreme_estimator/extreme_models/margin_model/margin_function/combined_margin_function.py
index 17a8cfcddbc15193cc5ff272785900c5c198c7b4..59019ccacba4296b71719d66209564a86d408ca8 100644
--- a/extreme_estimator/extreme_models/margin_model/margin_function/combined_margin_function.py
+++ b/extreme_estimator/extreme_models/margin_model/margin_function/combined_margin_function.py
@@ -5,7 +5,7 @@ import numpy as np
from extreme_estimator.extreme_models.margin_model.margin_function.abstract_margin_function import \
AbstractMarginFunction
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
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 0f87191e5392b7c3e25bd5488e66420a628cecff..bc97b77b85ef197e361255b3ccd6bffc151bcaf1 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
@@ -3,7 +3,7 @@ from typing import Dict
import numpy as np
from extreme_estimator.extreme_models.margin_model.param_function.param_function import ParamFunction
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from extreme_estimator.extreme_models.margin_model.margin_function.abstract_margin_function import \
AbstractMarginFunction
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
@@ -22,7 +22,7 @@ class IndependentMarginFunction(AbstractMarginFunction):
assert self.gev_param_name_to_param_function is not None
assert len(self.gev_param_name_to_param_function) == 3
gev_params = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ 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)
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 42f875241db7174ce90641482b9f37d12a2581a3..65749ca67407fd87f7b5b77e28baf4528f686a92 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
@@ -5,7 +5,7 @@ from extreme_estimator.extreme_models.margin_model.margin_function.independent_m
from extreme_estimator.extreme_models.margin_model.param_function.linear_coef import LinearCoef
from extreme_estimator.extreme_models.margin_model.param_function.param_function import ConstantParamFunction, \
ParamFunction, LinearParamFunction
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.coordinates.abstract_coordinates import AbstractCoordinates
@@ -40,7 +40,7 @@ class LinearMarginFunction(IndependentMarginFunction):
assert 0 < dim <= coordinates.nb_coordinates, "dim={}, nb_columns={}".format(dim, coordinates.nb_coordinates)
# Map each gev_param_name to its corresponding param_function
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
linear_coef = self.gev_param_name_to_linear_coef[gev_param_name]
# By default, if linear_dims are not specified, a constantParamFunction is chosen
if gev_param_name not in self.gev_param_name_to_linear_dims.keys():
@@ -57,7 +57,7 @@ class LinearMarginFunction(IndependentMarginFunction):
def from_coef_dict(cls, coordinates: AbstractCoordinates, gev_param_name_to_linear_dims: Dict[str, List[int]],
coef_dict: Dict[str, float]):
gev_param_name_to_linear_coef = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
linear_dims = gev_param_name_to_linear_dims.get(gev_param_name, [])
linear_coef = LinearCoef.from_coef_dict(coef_dict=coef_dict, gev_param_name=gev_param_name,
linear_dims=linear_dims)
@@ -67,7 +67,7 @@ class LinearMarginFunction(IndependentMarginFunction):
@property
def form_dict(self) -> Dict[str, str]:
form_dict = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
linear_dims = self.gev_param_name_to_linear_dims.get(gev_param_name, [])
form_dict.update(self.gev_param_name_to_linear_coef[gev_param_name].form_dict(linear_dims=linear_dims))
return form_dict
@@ -75,7 +75,7 @@ class LinearMarginFunction(IndependentMarginFunction):
@property
def coef_dict(self) -> Dict[str, float]:
coef_dict = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
linear_dims = self.gev_param_name_to_linear_dims.get(gev_param_name, [])
coef_dict.update(self.gev_param_name_to_linear_coef[gev_param_name].coef_dict(linear_dims=linear_dims))
return coef_dict
diff --git a/extreme_estimator/extreme_models/margin_model/margin_function/utils.py b/extreme_estimator/extreme_models/margin_model/margin_function/utils.py
index 458628dda0920ce246da513a6adece0f74cd5726..d2e0e1c2bf718a1862e7c1218ca01dff1c5802a3 100644
--- a/extreme_estimator/extreme_models/margin_model/margin_function/utils.py
+++ b/extreme_estimator/extreme_models/margin_model/margin_function/utils.py
@@ -1,8 +1,6 @@
-import numpy as np
-
from extreme_estimator.extreme_models.margin_model.margin_function.abstract_margin_function import \
AbstractMarginFunction
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
def relative_abs_error(reference_value, fitted_value):
@@ -23,7 +21,7 @@ def error_dict_between_margin_functions(reference: AbstractMarginFunction, fitte
reference_values = reference.gev_value_name_to_serie
fitted_values = fitted.gev_value_name_to_serie
gev_param_name_to_error_serie = {}
- for gev_value_name in GevParams.GEV_VALUE_NAMES:
+ 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
diff --git a/extreme_estimator/extreme_models/margin_model/smooth_margin_model.py b/extreme_estimator/extreme_models/margin_model/smooth_margin_model.py
index b2089aa11935f80ea45d832cfa37052dadcc4ff9..57d4254ba138a9fa533758f1772927f6581c6bf5 100644
--- a/extreme_estimator/extreme_models/margin_model/smooth_margin_model.py
+++ b/extreme_estimator/extreme_models/margin_model/smooth_margin_model.py
@@ -3,14 +3,12 @@ from typing import Dict
import numpy as np
import pandas as pd
-from extreme_estimator.extreme_models.margin_model.margin_function.abstract_margin_function import \
- AbstractMarginFunction
from extreme_estimator.extreme_models.margin_model.abstract_margin_model import AbstractMarginModel
from extreme_estimator.extreme_models.margin_model.margin_function.linear_margin_function import LinearMarginFunction
from extreme_estimator.extreme_models.margin_model.param_function.linear_coef import LinearCoef
from extreme_estimator.extreme_models.utils import safe_run_r_estimator, r, retrieve_fitted_values, get_coord, \
get_margin_formula
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
class LinearMarginModel(AbstractMarginModel):
@@ -37,7 +35,7 @@ class LinearMarginModel(AbstractMarginModel):
default_intercept = 1
default_slope = 0.01
gev_param_name_and_dim_to_coef = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
gev_param_name_and_dim_to_coef[(gev_param_name, 0)] = default_intercept
for dim in [1, 2, 3]:
gev_param_name_and_dim_to_coef[(gev_param_name, dim)] = default_slope
@@ -46,7 +44,7 @@ class LinearMarginModel(AbstractMarginModel):
@staticmethod
def gev_param_name_to_linear_coef(param_name_and_dim_to_coef):
gev_param_name_to_linear_coef = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
dim_to_coef = {dim: param_name_and_dim_to_coef[(gev_param_name, dim)] for dim in [0, 1, 2, 3]}
linear_coef = LinearCoef(gev_param_name=gev_param_name, dim_to_coef=dim_to_coef)
gev_param_name_to_linear_coef[gev_param_name] = linear_coef
@@ -55,7 +53,7 @@ class LinearMarginModel(AbstractMarginModel):
@classmethod
def from_coef_list(cls, coordinates, gev_param_name_to_coef_list):
params = {}
- for gev_param_name in GevParams.GEV_PARAM_NAMES:
+ for gev_param_name in GevParams.PARAM_NAMES:
for dim, coef in enumerate(gev_param_name_to_coef_list[gev_param_name]):
params[(gev_param_name, dim)] = coef
return cls(coordinates, params_sample=params, params_start_fit=params)
@@ -79,41 +77,41 @@ class ConstantMarginModel(LinearMarginModel):
class LinearShapeDim1MarginModel(LinearMarginModel):
def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_linear_dims=None):
- super().load_margin_functions({GevParams.GEV_SHAPE: [1]})
+ super().load_margin_functions({GevParams.SHAPE: [1]})
class LinearScaleDim1MarginModel(LinearMarginModel):
def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_linear_dims=None):
- super().load_margin_functions({GevParams.GEV_SCALE: [1]})
+ super().load_margin_functions({GevParams.SCALE: [1]})
class LinearShapeDim1and2MarginModel(LinearMarginModel):
def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_linear_dims=None):
- super().load_margin_functions({GevParams.GEV_SHAPE: [1, 2]})
+ super().load_margin_functions({GevParams.SHAPE: [1, 2]})
class LinearAllParametersDim1MarginModel(LinearMarginModel):
def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_linear_dims=None):
- super().load_margin_functions({GevParams.GEV_SHAPE: [1],
- GevParams.GEV_LOC: [1],
- GevParams.GEV_SCALE: [1]})
+ super().load_margin_functions({GevParams.SHAPE: [1],
+ GevParams.LOC: [1],
+ GevParams.SCALE: [1]})
class LinearMarginModelExample(LinearMarginModel):
def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_linear_dims=None):
- super().load_margin_functions({GevParams.GEV_SHAPE: [1],
- GevParams.GEV_LOC: [2],
- GevParams.GEV_SCALE: [1]})
+ super().load_margin_functions({GevParams.SHAPE: [1],
+ GevParams.LOC: [2],
+ GevParams.SCALE: [1]})
class LinearAllParametersAllDimsMarginModel(LinearMarginModel):
def load_margin_functions(self, margin_function_class: type = None, gev_param_name_to_linear_dims=None):
all_dims = list(range(1, self.coordinates.nb_coordinates + 1))
- super().load_margin_functions({GevParams.GEV_SHAPE: all_dims.copy(),
- GevParams.GEV_LOC: all_dims.copy(),
- GevParams.GEV_SCALE: all_dims.copy()})
+ super().load_margin_functions({GevParams.SHAPE: all_dims.copy(),
+ GevParams.LOC: all_dims.copy(),
+ GevParams.SCALE: all_dims.copy()})
diff --git a/extreme_estimator/gev/gevmle_fit.py b/extreme_estimator/gev/gevmle_fit.py
deleted file mode 100644
index c63732eb578a72b1e581a9b2b2117613a735cdbf..0000000000000000000000000000000000000000
--- a/extreme_estimator/gev/gevmle_fit.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import rpy2.robjects as ro
-import numpy as np
-import rpy2.robjects.numpy2ri as rpyn
-import os.path as op
-
-# Defining some constants
-from extreme_estimator.gev_params import GevParams
-from extreme_estimator.extreme_models.utils import get_associated_r_file
-
-from extreme_estimator.extreme_models.utils import r
-
-
-# def gev_mle_fit(x_gev: np.ndarray, start_loc=0.0, start_scale=1.0, start_shape=1.0):
-# assert np.ndim(x_gev) == 1
-# assert start_scale > 0
-# r = ro.r
-# x_gev = rpyn.numpy2ri(x_gev)
-# r.assign('x_gev', x_gev)
-# r.assign('python_wrapping', True)
-# r.source(file=get_associated_r_file(python_filepath=op.abspath(__file__)))
-# print(start_loc, start_scale, start_shape)
-# res = r.mle_gev(loc=start_loc, scale=start_scale, shape=start_shape)
-# mle_params = dict(r.attr(res, 'coef').items())
-# print('mle params', mle_params)
-# return mle_params
-
-def spatial_extreme_gevmle_fit(x_gev):
- res = r.gevmle(x_gev, method="Nelder")
- return dict(zip(res.names, res))
-
-
-class GevMleFit(object):
-
- def __init__(self, x_gev: np.ndarray):
- assert np.ndim(x_gev) == 1
- assert len(x_gev) > 1
- self.x_gev = x_gev
- self.mle_params = spatial_extreme_gevmle_fit(x_gev)
- self.gev_params = GevParams.from_dict(self.mle_params)
- self.shape = self.mle_params[GevParams.GEV_SHAPE]
- self.scale = self.mle_params[GevParams.GEV_SCALE]
- self.loc = self.mle_params[GevParams.GEV_LOC]
diff --git a/extreme_estimator/gev_params.py b/extreme_estimator/gev_params.py
deleted file mode 100644
index 2f69e55ae9c663eb0947f16a7fa79a926e294717..0000000000000000000000000000000000000000
--- a/extreme_estimator/gev_params.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import numpy as np
-import pandas as pd
-
-from extreme_estimator.extreme_models.utils import r
-
-
-class GevParams(object):
- # GEV parameters
- GEV_SCALE = 'scale'
- GEV_LOC = 'loc'
- GEV_SHAPE = 'shape'
- GEV_PARAM_NAMES = [GEV_LOC, GEV_SCALE, GEV_SHAPE]
- # GEV quantiles
- GEV_QUANTILE_10 = 'quantile 10'
- GEV_QUANTILE_100 = 'quantile 100'
- GEV_QUANTILE_1000 = 'quantile 1000'
- GEV_QUANTILE_NAMES = [GEV_QUANTILE_10, GEV_QUANTILE_100, GEV_QUANTILE_1000]
- GEV_QUANTILE_P_VALUES = [0.9, 0.99, 0.999]
- # GEV values
- GEV_VALUE_NAMES = GEV_PARAM_NAMES + GEV_QUANTILE_NAMES[:-1]
-
- # GEV parameters
-
- def __init__(self, loc: float, scale: float, shape: float):
- self.location = loc
- self.scale = scale
- self.shape = shape
- # self.scale = max(self.scale, 1e-4)
- assert self.scale > 0
-
- @classmethod
- def from_dict(cls, params: dict):
- return cls(**params)
-
- def to_dict(self) -> dict:
- return {
- self.GEV_LOC: self.location,
- self.GEV_SCALE: self.scale,
- self.GEV_SHAPE: self.shape,
- }
-
- def to_array(self) -> np.ndarray:
- return self.to_serie().values
-
- def to_serie(self) -> pd.Series:
- return pd.Series(self.to_dict(), index=self.GEV_PARAM_NAMES)
-
- # GEV quantiles
-
- def qgev(self, p) -> float:
- return r.qgev(p, self.location, self.scale, self.shape)[0]
-
- @property
- def quantile_name_to_p(self) -> dict:
- return dict(zip(self.GEV_QUANTILE_NAMES, self.GEV_QUANTILE_P_VALUES))
-
- @property
- def quantile_dict(self) -> dict:
- return {quantile_name: self.qgev(p) for quantile_name, p in self.quantile_name_to_p.items()}
-
- # GEV values
-
- @property
- def value_dict(self) -> dict:
- return {**self.to_dict(), **self.quantile_dict}
-
- @property
- def value_serie(self) -> pd.Series:
- return pd.Series(self.value_dict, index=self.GEV_VALUE_NAMES)
-
-
diff --git a/extreme_estimator/gev/__init__.py b/extreme_estimator/margin_fits/__init__.py
similarity index 100%
rename from extreme_estimator/gev/__init__.py
rename to extreme_estimator/margin_fits/__init__.py
diff --git a/extreme_estimator/margin_fits/abstract_params.py b/extreme_estimator/margin_fits/abstract_params.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f180d180e1ebd12690404a089935dc5673c080e
--- /dev/null
+++ b/extreme_estimator/margin_fits/abstract_params.py
@@ -0,0 +1,62 @@
+from typing import List
+
+import numpy as np
+import pandas as pd
+
+from extreme_estimator.extreme_models.utils import r
+
+
+class AbstractParams(object):
+ # Parameters
+ PARAM_NAMES = []
+ # Quantile
+ QUANTILE_10 = 'quantile 10'
+ QUANTILE_100 = 'quantile 100'
+ QUANTILE_1000 = 'quantile 1000'
+ QUANTILE_NAMES = [QUANTILE_10, QUANTILE_100, QUANTILE_1000][:-1]
+ QUANTILE_P_VALUES = [0.9, 0.99, 0.999]
+ # Summary
+ SUMMARY_NAMES = PARAM_NAMES + QUANTILE_NAMES
+
+ @classmethod
+ def from_dict(cls, params: dict):
+ return cls(**params)
+
+ # Parameters
+
+ @property
+ def param_values(self) -> List[float]:
+ raise NotImplementedError
+
+ def to_dict(self) -> dict:
+ return dict(zip(self.PARAM_NAMES, self.param_values))
+
+ def to_serie(self) -> pd.Series:
+ return pd.Series(self.to_dict(), index=self.PARAM_NAMES)
+
+ def to_array(self) -> np.ndarray:
+ return self.to_serie().values
+
+ # Quantile
+
+ def quantile(self, p) -> float:
+ raise NotImplementedError
+
+ @property
+ def quantile_name_to_p(self) -> dict:
+ return dict(zip(self.QUANTILE_NAMES, self.QUANTILE_P_VALUES))
+
+ @property
+ def quantile_name_to_value(self) -> dict:
+ return {quantile_name: self.quantile(p) for quantile_name, p in self.quantile_name_to_p.items()}
+
+ # Summary (i.e. parameters & quantiles)
+
+ @property
+ def summary_dict(self) -> dict:
+ return {**self.to_dict(), **self.quantile_name_to_value}
+
+ @property
+ def summary_serie(self) -> pd.Series:
+ return pd.Series(self.summary_dict, index=self.SUMMARY_NAMES)
+
diff --git a/extreme_estimator/margin_fits/extreme_params.py b/extreme_estimator/margin_fits/extreme_params.py
new file mode 100644
index 0000000000000000000000000000000000000000..60bbeca3e5dfebbc04cb6a037b3269c244090d30
--- /dev/null
+++ b/extreme_estimator/margin_fits/extreme_params.py
@@ -0,0 +1,20 @@
+from extreme_estimator.margin_fits.abstract_params import AbstractParams
+
+
+class ExtremeParams(AbstractParams):
+
+ # Extreme parameters
+ SCALE = 'scale'
+ LOC = 'loc'
+ SHAPE = 'shape'
+ PARAM_NAMES = [LOC, SCALE, SHAPE]
+
+ def __init__(self, loc: float, scale: float, shape: float):
+ self.location = loc
+ self.scale = scale
+ self.shape = shape
+ assert self.scale > 0
+
+ @property
+ def param_values(self):
+ return [self.location, self.scale, self.shape]
\ No newline at end of file
diff --git a/test/test_extreme_estimator/test_gev/__init__.py b/extreme_estimator/margin_fits/gev/__init__.py
similarity index 100%
rename from test/test_extreme_estimator/test_gev/__init__.py
rename to extreme_estimator/margin_fits/gev/__init__.py
diff --git a/extreme_estimator/margin_fits/gev/gev_params.py b/extreme_estimator/margin_fits/gev/gev_params.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba743f8ad641e67ea41ce6f72e175e596d75b066
--- /dev/null
+++ b/extreme_estimator/margin_fits/gev/gev_params.py
@@ -0,0 +1,12 @@
+from extreme_estimator.extreme_models.utils import r
+from extreme_estimator.margin_fits.extreme_params import ExtremeParams
+
+
+class GevParams(ExtremeParams):
+
+ def __init__(self, loc: float, scale: float, shape: float, block_size: int = None):
+ super().__init__(loc, scale, shape)
+ self.block_size = block_size
+
+ def quantile(self, p) -> float:
+ return r.qgev(p, self.location, self.scale, self.shape)[0]
diff --git a/extreme_estimator/gev/gevmle_fit.R b/extreme_estimator/margin_fits/gev/gevmle_fit.R
similarity index 100%
rename from extreme_estimator/gev/gevmle_fit.R
rename to extreme_estimator/margin_fits/gev/gevmle_fit.R
diff --git a/extreme_estimator/margin_fits/gev/gevmle_fit.py b/extreme_estimator/margin_fits/gev/gevmle_fit.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ad75d186c47271b6b11b6555b582ea5a0660979
--- /dev/null
+++ b/extreme_estimator/margin_fits/gev/gevmle_fit.py
@@ -0,0 +1,14 @@
+import numpy as np
+
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
+from extreme_estimator.margin_fits.margin_fits_utils import spatial_extreme_gevmle_fit
+
+
+class GevMleFit(object):
+
+ def __init__(self, x_gev: np.ndarray, block_size=None):
+ assert np.ndim(x_gev) == 1
+ assert len(x_gev) > 1
+ self.x_gev = x_gev
+ self.mle_params = spatial_extreme_gevmle_fit(x_gev)
+ self.gev_params = GevParams.from_dict({**self.mle_params, 'block_size': block_size})
diff --git a/extreme_estimator/margin_fits/gpd/__init__.py b/extreme_estimator/margin_fits/gpd/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/extreme_estimator/margin_fits/gpd/gpd_params.py b/extreme_estimator/margin_fits/gpd/gpd_params.py
new file mode 100644
index 0000000000000000000000000000000000000000..3eb4233161e4c18e1e7ef6675822cb2a0544d32e
--- /dev/null
+++ b/extreme_estimator/margin_fits/gpd/gpd_params.py
@@ -0,0 +1,12 @@
+from extreme_estimator.extreme_models.utils import r
+from extreme_estimator.margin_fits.extreme_params import ExtremeParams
+
+
+class GpdParams(ExtremeParams):
+
+ def __init__(self, loc: float, scale: float, shape: float, threshold: float = None):
+ super().__init__(loc, scale, shape)
+ self.threshold = threshold
+
+ def quantile(self, p) -> float:
+ return r.qgpd(p, self.location, self.scale, self.shape)[0]
diff --git a/extreme_estimator/margin_fits/gpd/gpdmle_fit.py b/extreme_estimator/margin_fits/gpd/gpdmle_fit.py
new file mode 100644
index 0000000000000000000000000000000000000000..da57af36852d8480a4474eb6807402afac893752
--- /dev/null
+++ b/extreme_estimator/margin_fits/gpd/gpdmle_fit.py
@@ -0,0 +1,15 @@
+import numpy as np
+
+from extreme_estimator.margin_fits.gpd.gpd_params import GpdParams
+from extreme_estimator.margin_fits.margin_fits_utils import spatial_extreme_gpdmle_fit
+
+
+class GpdMleFit(object):
+
+ def __init__(self, x_gev: np.ndarray, threshold):
+ assert np.ndim(x_gev) == 1
+ assert len(x_gev) > 1
+ self.x_gev = x_gev
+ self.threshold = threshold
+ self.mle_params = spatial_extreme_gpdmle_fit(x_gev, threshold)
+ self.gev_params = GpdParams.from_dict({**self.mle_params, 'threshold': threshold})
\ No newline at end of file
diff --git a/extreme_estimator/margin_fits/margin_fits_utils.py b/extreme_estimator/margin_fits/margin_fits_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c630955c67c97d937247cf8c51847cd9e99b9368
--- /dev/null
+++ b/extreme_estimator/margin_fits/margin_fits_utils.py
@@ -0,0 +1,20 @@
+from extreme_estimator.extreme_models.utils import r
+
+"""
+These two functions are “extremely light†functions to fit the GEV/GPD. These functions are mainlyuseful
+to compute starting values for the Schlather and Smith mode
+If more refined (univariate) analysis have to be performed, users should use more specialised pack-ages
+ - e.g. POT, evd, ismev, . . . .
+"""
+
+
+def spatial_extreme_gevmle_fit(x_gev):
+ res = r.gevmle(x_gev, method="Nelder")
+ return dict(zip(res.names, res))
+
+
+def spatial_extreme_gpdmle_fit(x_gev, threshold):
+ res = r.gpdmle(x_gev, threshold, method="Nelder")
+ return dict(zip(res.names, res))
+
+# todo: define more robust function gevmle_fit/gpdmle_fit
diff --git a/safran_study/safran.py b/safran_study/safran.py
index 8e37cd3bd45f602dc40e8d2c6a3bcdb4900f7e0d..2009ac91d6b19003e16e4e219a6d872aae6d23df 100644
--- a/safran_study/safran.py
+++ b/safran_study/safran.py
@@ -4,15 +4,14 @@ import matplotlib.colorbar as cbar
import os.path as op
from collections import OrderedDict
-import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
from matplotlib import cm
-from mpl_toolkits.axes_grid1 import AxesGrid, make_axes_locatable
+from mpl_toolkits.axes_grid1 import make_axes_locatable
from netCDF4 import Dataset
-from extreme_estimator.gev.gevmle_fit import GevMleFit
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gevmle_fit import GevMleFit
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from safran_study.massif import safran_massif_names_from_datasets
from safran_study.shifted_color_map import shiftedColorMap
from safran_study.snowfall_annual_maxima import SafranSnowfall
@@ -58,7 +57,7 @@ class Safran(object):
plt.show()
def visualize_gev_fit_with_cmap(self, show=True, axes=None):
- params_names = GevParams.GEV_VALUE_NAMES
+ params_names = GevParams.SUMMARY_NAMES
if axes is None:
fig, axes = plt.subplots(1, len(params_names))
fig.subplots_adjust(hspace=1.0, wspace=1.0)
@@ -77,7 +76,7 @@ class Safran(object):
# Load the shifted cmap to center on a middle point
cmap = [plt.cm.coolwarm, plt.cm.bwr, plt.cm.seismic][1]
- if gev_param_name == GevParams.GEV_SHAPE:
+ if gev_param_name == GevParams.SHAPE:
shifted_cmap = shiftedColorMap(cmap, midpoint=midpoint, name='shifted')
norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
else:
@@ -113,8 +112,8 @@ class Safran(object):
@property
def df_gev_mle_each_massif(self):
- # Fit a gev n each massif
- massif_to_gev_mle = {massif_name: GevMleFit(self.df_annual_maxima[massif_name]).gev_params.value_serie
+ # Fit a margin_fits n each massif
+ massif_to_gev_mle = {massif_name: GevMleFit(self.df_annual_maxima[massif_name]).gev_params.summary_serie
for massif_name in self.safran_massif_names}
return pd.DataFrame(massif_to_gev_mle, columns=self.safran_massif_names)
diff --git a/safran_study/visualize_safran.py b/safran_study/visualize_safran.py
index 5937e40d9eeb7078dd3338a57b0d90e915a2f1a6..8fbcdaa67800b992d2a221e90251f67c11011de3 100644
--- a/safran_study/visualize_safran.py
+++ b/safran_study/visualize_safran.py
@@ -1,9 +1,4 @@
-import pandas as pd
-
-from extreme_estimator.gev_params import GevParams
from safran_study.safran import Safran
-from safran_study.safran_extended import ExtendedSafran
-from utils import VERSION
from itertools import product
diff --git a/test/test_extreme_estimator/test_extreme_models/test_margin_model.py b/test/test_extreme_estimator/test_extreme_models/test_margin_model.py
index c49a3bd355bf23bb624e6089d84c56cdcd324750..638e321f5509f61cdb52b3234937c2fa94c1c19e 100644
--- a/test/test_extreme_estimator/test_extreme_models/test_margin_model.py
+++ b/test/test_extreme_estimator/test_extreme_models/test_margin_model.py
@@ -1,6 +1,6 @@
import unittest
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from extreme_estimator.extreme_models.margin_model.smooth_margin_model import LinearShapeDim1MarginModel, \
LinearAllParametersAllDimsMarginModel
from spatio_temporal_dataset.coordinates.spatial_coordinates.generated_spatial_coordinates import CircleSpatialCoordinates
@@ -20,7 +20,7 @@ class VisualizationMarginModel(unittest.TestCase):
def test_example_visualization_1D(self):
coordinates = LinSpaceSpatialCoordinates.from_nb_points(nb_points=self.nb_points)
- margin_model = self.margin_model(coordinates=coordinates, params_sample={(GevParams.GEV_SHAPE, 1): 0.02})
+ margin_model = self.margin_model(coordinates=coordinates, params_sample={(GevParams.SHAPE, 1): 0.02})
margin_model.margin_function_sample.visualize(show=self.DISPLAY)
self.assertTrue(True)
diff --git a/test/test_extreme_estimator/test_margin_fits/__init__.py b/test/test_extreme_estimator/test_margin_fits/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/test/test_extreme_estimator/test_margin_fits/test_gev/__init__.py b/test/test_extreme_estimator/test_margin_fits/test_gev/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/test/test_extreme_estimator/test_gev_params.py b/test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_params.py
similarity index 68%
rename from test/test_extreme_estimator/test_gev_params.py
rename to test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_params.py
index 8ebbf28282dad22b2dc478f91a864f0863adb365..dab5ca5508814d9a6269addf2ec02fc24d7ed470 100644
--- a/test/test_extreme_estimator/test_gev_params.py
+++ b/test/test_extreme_estimator/test_margin_fits/test_gev/test_gev_params.py
@@ -2,9 +2,7 @@ import unittest
import numpy as np
-from extreme_estimator.extreme_models.utils import r, set_seed_r
-from extreme_estimator.gev.gevmle_fit import GevMleFit
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
class TestGevParams(unittest.TestCase):
@@ -12,7 +10,7 @@ class TestGevParams(unittest.TestCase):
def test_quantile(self):
# For GEV(1,1,1), the repartition function is exp(-y^-1) the formula for the quantile p is -1/log(p)
gev_params = GevParams(loc=1.0, shape=1.0, scale=1.0)
- quantile_dict = gev_params.quantile_dict
+ quantile_dict = gev_params.quantile_name_to_value
for quantile_name, p in gev_params.quantile_name_to_p.items():
self.assertAlmostEqual(- 1 / np.log(p), quantile_dict[quantile_name])
diff --git a/test/test_extreme_estimator/test_gev/test_gevmle_fit.py b/test/test_extreme_estimator/test_margin_fits/test_gev/test_gevmle_fit.py
similarity index 93%
rename from test/test_extreme_estimator/test_gev/test_gevmle_fit.py
rename to test/test_extreme_estimator/test_margin_fits/test_gev/test_gevmle_fit.py
index 97b2d8ba0999b712deb62ea7475c0069bb9aea16..99a56cb314b1c8c14c0ea3287f4cc6864a87564d 100644
--- a/test/test_extreme_estimator/test_gev/test_gevmle_fit.py
+++ b/test/test_extreme_estimator/test_margin_fits/test_gev/test_gevmle_fit.py
@@ -3,7 +3,7 @@ import unittest
import numpy as np
from extreme_estimator.extreme_models.utils import r, set_seed_r
-from extreme_estimator.gev.gevmle_fit import GevMleFit
+from extreme_estimator.margin_fits.gev.gevmle_fit import GevMleFit
class TestGevMleFit(unittest.TestCase):
diff --git a/test/test_unitary/test_rmaxstab/test_rmaxstab_with_margin.py b/test/test_unitary/test_rmaxstab/test_rmaxstab_with_margin.py
index 1db26310de084ddf2c1d8f9ad1234eee4951a5e8..0f485e949e363bdd88c02ecb38e1ea760bb76993 100644
--- a/test/test_unitary/test_rmaxstab/test_rmaxstab_with_margin.py
+++ b/test/test_unitary/test_rmaxstab/test_rmaxstab_with_margin.py
@@ -5,7 +5,7 @@ import numpy as np
from extreme_estimator.extreme_models.margin_model.smooth_margin_model import ConstantMarginModel, \
LinearAllParametersAllDimsMarginModel
from extreme_estimator.extreme_models.utils import r
-from extreme_estimator.gev_params import GevParams
+from extreme_estimator.margin_fits.gev.gev_params import GevParams
from spatio_temporal_dataset.dataset.simulation_dataset import FullSimulatedDataset
from test.test_unitary.test_rmaxstab.test_rmaxstab_without_margin import TestRMaxStab
from test.test_unitary.test_unitary_abstract import TestUnitaryAbstract
@@ -31,9 +31,9 @@ class TestRMaxStabWithMarginConstant(TestUnitaryAbstract):
coordinates, max_stable_model = TestRMaxStab.python_code()
# Load margin model
gev_param_name_to_coef_list = {
- GevParams.GEV_LOC: [0.2],
- GevParams.GEV_SHAPE: [0.2],
- GevParams.GEV_SCALE: [0.2],
+ 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)
# Load dataset
@@ -77,9 +77,9 @@ class TestRMaxStabWithLinearMargin(TestUnitaryAbstract):
coordinates, max_stable_model = TestRMaxStab.python_code()
# Load margin model
gev_param_name_to_coef_list = {
- GevParams.GEV_LOC: [-10, 0, 2],
- GevParams.GEV_SHAPE: [2, -3, 0],
- GevParams.GEV_SCALE: [5, 2, 1],
+ 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)
# Load dataset