Commit 6172bedc authored by Le Roux Erwan's avatar Le Roux Erwan
Browse files

[projection snowfall] add the 27 non stationary spline models of interest.

parent c85b1f9c
No related merge requests found
Showing with 289 additions and 73 deletions
+289 -73
...@@ -4,45 +4,62 @@ from extreme_fit.function.param_function.polynomial_coef import PolynomialCoef, ...@@ -4,45 +4,62 @@ from extreme_fit.function.param_function.polynomial_coef import PolynomialCoef,
from extreme_fit.function.param_function.spline_coef import SplineCoef, SplineAllCoef from extreme_fit.function.param_function.spline_coef import SplineCoef, SplineAllCoef
def load_param_name_to_polynomial_all_coef(param_name_to_list_dim_and_degree, def load_polynomial_all_coef(param_name, param_name_and_dim_and_degree_to_default_coef,
param_name_and_dim_and_degree_to_default_coef): param_name_to_list_dim_and_degree):
param_name_to_polynomial_all_coef = {} dim_to_polynomial_coef = {}
param_names = list(set([e[0] for e in param_name_and_dim_and_degree_to_default_coef.keys()])) for dim, max_degree in param_name_to_list_dim_and_degree.get(param_name, []):
for param_name in param_names: degree_to_coef = {}
dim_to_polynomial_coef = {} for (param_name_loop, dim_loop, degree), coef in param_name_and_dim_and_degree_to_default_coef.items():
for dim, max_degree in param_name_to_list_dim_and_degree.get(param_name, []): if param_name == param_name_loop and dim == dim_loop and degree <= max_degree:
degree_to_coef = {} degree_to_coef[degree] = coef
for (param_name_loop, dim_loop, degree), coef in param_name_and_dim_and_degree_to_default_coef.items(): polynomial_coef = PolynomialCoef(param_name, degree_to_coef=degree_to_coef)
if param_name == param_name_loop and dim == dim_loop and degree <= max_degree: dim_to_polynomial_coef[dim] = polynomial_coef
degree_to_coef[degree] = coef if len(dim_to_polynomial_coef) == 0:
polynomial_coef = PolynomialCoef(param_name, degree_to_coef=degree_to_coef) intercept = param_name_and_dim_and_degree_to_default_coef[(param_name, 0, 0)]
dim_to_polynomial_coef[dim] = polynomial_coef dim_to_polynomial_coef = None
if len(dim_to_polynomial_coef) == 0: else:
intercept = param_name_and_dim_and_degree_to_default_coef[(param_name, 0, 0)] intercept = None
dim_to_polynomial_coef = None polynomial_all_coef = PolynomialAllCoef(param_name=param_name,
else: dim_to_polynomial_coef=dim_to_polynomial_coef,
intercept = None intercept=intercept)
polynomial_all_coef = PolynomialAllCoef(param_name=param_name, return polynomial_all_coef
dim_to_polynomial_coef=dim_to_polynomial_coef,
intercept=intercept)
param_name_to_polynomial_all_coef[param_name] = polynomial_all_coef def load_spline_all_coef(param_name, param_name_to_list_dim_and_degree_and_nb_intervals):
return param_name_to_polynomial_all_coef dim_to_spline_coef = {}
for dim, max_degree, nb_intervals in param_name_to_list_dim_and_degree_and_nb_intervals.get(param_name, []):
nb_coefficients = nb_intervals + 1
coefficients = np.arange(nb_coefficients)
knots = np.arange(nb_coefficients + max_degree + 1)
dim_to_spline_coef[dim] = SplineCoef(param_name, knots=knots, coefficients=coefficients)
if len(dim_to_spline_coef) == 0:
dim_to_spline_coef = None
spline_all_coef = SplineAllCoef(param_name=param_name,
dim_to_spline_coef=dim_to_spline_coef)
return spline_all_coef
def load_param_name_to_spline_all_coef(param_name_to_list_dim_and_degree_and_nb_intervals, def load_param_name_to_spline_all_coef(param_name_to_list_dim_and_degree_and_nb_intervals,
param_name_and_dim_and_degree_to_default_coef): param_name_and_dim_and_degree_to_default_coef):
param_name_to_spline_all_coef = {} param_name_to_spline_all_coef = {}
param_names = list(set([e[0] for e in param_name_and_dim_and_degree_to_default_coef.keys()])) param_names = list(set([e[0] for e in param_name_and_dim_and_degree_to_default_coef.keys()]))
for param_name in param_names: for param_name in param_names:
dim_to_spline_coef = {} list_dim_and_degree_and_nb_intervals = param_name_to_list_dim_and_degree_and_nb_intervals.get(param_name, [])
for dim, max_degree, nb_intervals in param_name_to_list_dim_and_degree_and_nb_intervals.get(param_name, []): if (len(list_dim_and_degree_and_nb_intervals) > 0) and (len(list_dim_and_degree_and_nb_intervals[0]) == 3):
nb_coefficients = nb_intervals + 1 all_coef = load_spline_all_coef(param_name, param_name_to_list_dim_and_degree_and_nb_intervals)
coefficients = np.arange(nb_coefficients) else:
knots = np.arange(nb_coefficients + max_degree + 1) all_coef = load_polynomial_all_coef(param_name, param_name_and_dim_and_degree_to_default_coef,
dim_to_spline_coef[dim] = SplineCoef(param_name, knots=knots, coefficients=coefficients) param_name_to_list_dim_and_degree_and_nb_intervals)
if len(dim_to_spline_coef) == 0: param_name_to_spline_all_coef[param_name] = all_coef
dim_to_spline_coef = None
spline_all_coef = SplineAllCoef(param_name=param_name,
dim_to_spline_coef=dim_to_spline_coef)
param_name_to_spline_all_coef[param_name] = spline_all_coef
return param_name_to_spline_all_coef return param_name_to_spline_all_coef
def load_param_name_to_polynomial_all_coef(param_name_to_list_dim_and_degree,
param_name_and_dim_and_degree_to_default_coef):
param_name_to_polynomial_all_coef = {}
param_names = list(set([e[0] for e in param_name_and_dim_and_degree_to_default_coef.keys()]))
for param_name in param_names:
polynomial_all_coef = load_polynomial_all_coef(param_name, param_name_and_dim_and_degree_to_default_coef,
param_name_to_list_dim_and_degree)
param_name_to_polynomial_all_coef[param_name] = polynomial_all_coef
return param_name_to_polynomial_all_coef
...@@ -32,7 +32,7 @@ class SplineMarginModel(AbstractTemporalLinearMarginModel): ...@@ -32,7 +32,7 @@ class SplineMarginModel(AbstractTemporalLinearMarginModel):
# Assert the order of list of dim and degree, to match the order of the form dict, # Assert the order of list of dim and degree, to match the order of the form dict,
# i.e. 1) spatial individual terms 2) combined terms 3) temporal individual terms # i.e. 1) spatial individual terms 2) combined terms 3) temporal individual terms
for param_name, list_dim_and_degree_and_nb_intervals in param_name_to_list_dim_and_degree_and_nb_intervals.items(): for param_name, list_dim_and_degree_and_nb_intervals in param_name_to_list_dim_and_degree_and_nb_intervals.items():
dims = [d for d, m, nb in list_dim_and_degree_and_nb_intervals] dims = [d for d, *_ in list_dim_and_degree_and_nb_intervals]
assert all([isinstance(d, int) or isinstance(d, tuple) for d in dims]) assert all([isinstance(d, int) or isinstance(d, tuple) for d in dims])
if self.coordinates.has_spatial_coordinates and self.coordinates.idx_x_coordinates in dims: if self.coordinates.has_spatial_coordinates and self.coordinates.idx_x_coordinates in dims:
assert dims.index(self.coordinates.idx_x_coordinates) == 0 assert dims.index(self.coordinates.idx_x_coordinates) == 0
...@@ -40,7 +40,8 @@ class SplineMarginModel(AbstractTemporalLinearMarginModel): ...@@ -40,7 +40,8 @@ class SplineMarginModel(AbstractTemporalLinearMarginModel):
assert dims.index(self.coordinates.idx_temporal_coordinates) == len(dims) - 1 assert dims.index(self.coordinates.idx_temporal_coordinates) == len(dims) - 1
# Assert that the degree are inferior to the max degree # Assert that the degree are inferior to the max degree
for list_dim_and_degree_and_nb_intervals in param_name_to_list_dim_and_degree_and_nb_intervals.values(): for list_dim_and_degree_and_nb_intervals in param_name_to_list_dim_and_degree_and_nb_intervals.values():
for _, max_degree, _ in list_dim_and_degree_and_nb_intervals: for _, *max_degree in list_dim_and_degree_and_nb_intervals:
max_degree = max_degree if isinstance(max_degree, float) else max_degree[0]
assert max_degree <= self.max_degree, 'Max degree (={}) specified is too high'.format(max_degree) assert max_degree <= self.max_degree, 'Max degree (={}) specified is too high'.format(max_degree)
# Load param_name_to_spline_all_coef # Load param_name_to_spline_all_coef
param_name_to_spline_all_coef = load_param_name_to_spline_all_coef( param_name_to_spline_all_coef = load_param_name_to_spline_all_coef(
......
...@@ -28,17 +28,157 @@ class NonStationaryTwoLinearShapeModel(SplineMarginModel): ...@@ -28,17 +28,157 @@ class NonStationaryTwoLinearShapeModel(SplineMarginModel):
class NonStationaryTwoLinearLocationOneLinearScaleModel(SplineMarginModel): class NonStationaryTwoLinearLocationOneLinearScaleModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None): def load_margin_function(self, param_name_to_dims=None):
# Degree 1, Two Linear sections for the location
return super().load_margin_function({ return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)], GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1)] GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1)]
}) })
class NonStationaryTwoLinearLocationOneLinearShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1)]
})
class NonStationaryTwoLinearLocationScaleModel(SplineMarginModel): class NonStationaryTwoLinearScaleOneLinearLocModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None): def load_margin_function(self, param_name_to_dims=None):
# Degree 1, Two Linear sections for the scale parameters return super().load_margin_function({
return super().load_margin_function({GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)]}) GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1)]
})
class NonStationaryTwoLinearScaleOneLinearShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1)]
})
class NonStationaryTwoLinearShapeOneLinearLocModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1)]
})
class NonStationaryTwoLinearShapeOneLinearScaleModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1)]
})
# Two Linearity with two one linearity
class NonStationaryTwoLinearLocationOneLinearScaleAndShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1)]
})
class NonStationaryTwoLinearScaleOneLinearLocAndShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1)]
})
class NonStationaryTwoLinearShapeOneLinearLocAndScaleModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1)]
})
# two linearity two times
class NonStationaryTwoLinearLocationAndScaleModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
})
class NonStationaryTwoLinearScaleAndShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
})
class NonStationaryTwoLinearLocationAndShape(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
})
# two linearity two times and one linearity
class NonStationaryTwoLinearLocationAndScaleOneLinearShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1)],
})
class NonStationaryTwoLinearScaleAndShapeOneLinearLocModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1)],
})
class NonStationaryTwoLinearLocationAndShapeOneLinearScaleModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1)],
})
# two linearity three times
class NonStationaryTwoLinearLocationAndScaleAndShapeModel(SplineMarginModel):
def load_margin_function(self, param_name_to_dims=None):
return super().load_margin_function({
GevParams.LOC: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SHAPE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
GevParams.SCALE: [(self.coordinates.idx_temporal_coordinates, 1, 2)],
})
...@@ -84,15 +84,22 @@ class VisualizerForProjectionEnsemble(object): ...@@ -84,15 +84,22 @@ class VisualizerForProjectionEnsemble(object):
ensemble_class_to_ensemble_fit[ensemble_fit_class] = ensemble_fit ensemble_class_to_ensemble_fit[ensemble_fit_class] = ensemble_fit
self.altitude_class_to_ensemble_class_to_ensemble_fit[altitude_class] = ensemble_class_to_ensemble_fit self.altitude_class_to_ensemble_class_to_ensemble_fit[altitude_class] = ensemble_class_to_ensemble_fit
@property
def has_elevation_non_stationarity(self):
return all([len(a) > 1 for a in self.altitudes_list])
def plot_for_visualizer_list(self, visualizer_list): def plot_for_visualizer_list(self, visualizer_list):
with_significance = False if self.has_elevation_non_stationarity:
for v in visualizer_list: with_significance = False
v.plot_moments() for v in visualizer_list:
# plot_histogram_all_trends_against_altitudes(self.massif_names, visualizer_list, v.plot_moments()
# with_significance=with_significance) plot_histogram_all_trends_against_altitudes(self.massif_names, visualizer_list,
# for relative in [True, False]: with_significance=with_significance)
# plot_shoe_plot_changes_against_altitude(self.massif_names, visualizer_list, relative=relative, for relative in [True, False]:
# with_significance=with_significance) plot_shoe_plot_changes_against_altitude(self.massif_names, visualizer_list, relative=relative,
with_significance=with_significance)
else:
print('here plot for one altitude visualizer')
def plot(self): def plot(self):
# Set limit for the plot # Set limit for the plot
......
from extreme_fit.model.margin_model.linear_margin_model.temporal_linear_margin_models import StationaryTemporalModel, \ from extreme_fit.model.margin_model.linear_margin_model.temporal_linear_margin_models import StationaryTemporalModel, \
NonStationaryLocationTemporalModel, NonStationaryScaleTemporalModel, NonStationaryShapeTemporalModel NonStationaryLocationTemporalModel, NonStationaryScaleTemporalModel, NonStationaryShapeTemporalModel, \
NonStationaryScaleAndShapeTemporalModel, NonStationaryLocationAndScaleAndShapeTemporalModel, \
NonStationaryLocationAndShapeTemporalModel, NonStationaryLocationAndScaleTemporalModel
from extreme_fit.model.margin_model.spline_margin_model.temporal_spline_model_degree_1 import \ from extreme_fit.model.margin_model.spline_margin_model.temporal_spline_model_degree_1 import \
NonStationaryTwoLinearLocationModel, NonStationaryTwoLinearShapeModel NonStationaryTwoLinearLocationModel, NonStationaryTwoLinearShapeModel, \
NonStationaryTwoLinearShapeOneLinearScaleModel, NonStationaryTwoLinearScaleOneLinearShapeModel, \
NonStationaryTwoLinearScaleAndShapeModel, NonStationaryTwoLinearShapeOneLinearLocAndScaleModel, \
NonStationaryTwoLinearScaleOneLinearLocAndShapeModel, NonStationaryTwoLinearShapeOneLinearLocModel, \
NonStationaryTwoLinearScaleOneLinearLocModel, NonStationaryTwoLinearScaleAndShapeOneLinearLocModel, \
NonStationaryTwoLinearLocationOneLinearScaleModel, NonStationaryTwoLinearLocationOneLinearScaleAndShapeModel, \
NonStationaryTwoLinearLocationOneLinearShapeModel, NonStationaryTwoLinearScaleModel, \
NonStationaryTwoLinearLocationAndShapeOneLinearScaleModel, NonStationaryTwoLinearLocationAndScaleAndShapeModel, \
NonStationaryTwoLinearLocationAndScaleOneLinearShapeModel, NonStationaryTwoLinearLocationAndScaleModel, \
NonStationaryTwoLinearLocationAndShape
SPLINE_MODELS_FOR_PROJECTION_ONE_ALTITUDE = [ SPLINE_MODELS_FOR_PROJECTION_ONE_ALTITUDE = [
# 1 model with three parameters
StationaryTemporalModel,
# 3 models with four parameters # Models with a constant Location parameter
NonStationaryLocationTemporalModel, StationaryTemporalModel,
# Simple linearity for the others
NonStationaryScaleTemporalModel, NonStationaryScaleTemporalModel,
NonStationaryShapeTemporalModel, NonStationaryShapeTemporalModel,
NonStationaryScaleAndShapeTemporalModel,
# Double linearity for the others
NonStationaryTwoLinearScaleModel,
NonStationaryTwoLinearShapeModel,
NonStationaryTwoLinearShapeOneLinearScaleModel,
NonStationaryTwoLinearScaleOneLinearShapeModel,
NonStationaryTwoLinearScaleAndShapeModel,
# Models with a linear location parameter
NonStationaryLocationTemporalModel,
# Simple linearity for the others
NonStationaryLocationAndScaleTemporalModel,
NonStationaryLocationAndShapeTemporalModel,
NonStationaryLocationAndScaleAndShapeTemporalModel,
# Double linearity for the others
NonStationaryTwoLinearScaleOneLinearLocModel,
NonStationaryTwoLinearShapeOneLinearLocModel,
NonStationaryTwoLinearScaleOneLinearLocAndShapeModel,
NonStationaryTwoLinearShapeOneLinearLocAndScaleModel,
NonStationaryTwoLinearScaleAndShapeOneLinearLocModel,
# Location only non-stationarity
# Models with linear location parameter with double linearity
NonStationaryTwoLinearLocationModel, NonStationaryTwoLinearLocationModel,
# Simple linearity for the others
NonStationaryTwoLinearLocationOneLinearScaleModel,
NonStationaryTwoLinearLocationOneLinearShapeModel,
NonStationaryTwoLinearLocationOneLinearScaleAndShapeModel,
# Double Linearity for the others
NonStationaryTwoLinearLocationAndScaleModel,
NonStationaryTwoLinearLocationAndScaleOneLinearShapeModel,
NonStationaryTwoLinearLocationAndShape,
NonStationaryTwoLinearLocationAndShapeOneLinearScaleModel,
NonStationaryTwoLinearLocationAndScaleAndShapeModel,
# Scale only non-stationarity
NonStationaryTwoLinearShapeModel, ]
# Shape only non-stationarity
# if __name__ == '__main__':
] print(len(set(SPLINE_MODELS_FOR_PROJECTION_ONE_ALTITUDE)))
\ No newline at end of file
...@@ -9,7 +9,7 @@ from extreme_fit.model.margin_model.polynomial_margin_model.polynomial_margin_mo ...@@ -9,7 +9,7 @@ from extreme_fit.model.margin_model.polynomial_margin_model.polynomial_margin_mo
NonStationaryQuadraticScaleModel, NonStationaryQuadraticLocationGumbelModel, NonStationaryQuadraticScaleGumbelModel NonStationaryQuadraticScaleModel, NonStationaryQuadraticLocationGumbelModel, NonStationaryQuadraticScaleGumbelModel
from extreme_fit.model.margin_model.spline_margin_model.temporal_spline_model_degree_1 import \ from extreme_fit.model.margin_model.spline_margin_model.temporal_spline_model_degree_1 import \
NonStationaryTwoLinearLocationModel, NonStationaryTwoLinearShapeModel, \ NonStationaryTwoLinearLocationModel, NonStationaryTwoLinearShapeModel, \
NonStationaryTwoLinearLocationOneLinearScaleModel NonStationaryTwoLinearLocationOneLinearScaleModel, NonStationaryTwoLinearLocationAndScaleAndShapeModel
from extreme_trend.trend_test.abstract_gev_trend_test import fitted_linear_margin_estimator from extreme_trend.trend_test.abstract_gev_trend_test import fitted_linear_margin_estimator
from extreme_fit.model.margin_model.utils import \ from extreme_fit.model.margin_model.utils import \
MarginFitMethod MarginFitMethod
...@@ -33,9 +33,10 @@ class TestGevTemporalSpline(unittest.TestCase): ...@@ -33,9 +33,10 @@ class TestGevTemporalSpline(unittest.TestCase):
start_loc = 0; start_scale = 1; start_shape = 1 start_loc = 0; start_scale = 1; start_shape = 1
""") """)
# Compute the stationary temporal margin with isMev # Compute the stationary temporal margin with isMev
self.start_year = -25 self.start_year = 0
nb_years = 51 nb_years = 51
self.last_year = self.start_year + nb_years - 1 self.last_year = self.start_year + nb_years - 1
self.middle_year = (self.last_year + self.start_year) / 2
years = np.array(range(self.start_year, self.start_year + nb_years)) years = np.array(range(self.start_year, self.start_year + nb_years))
df = pd.DataFrame({AbstractCoordinates.COORDINATE_T: years}) df = pd.DataFrame({AbstractCoordinates.COORDINATE_T: years})
self.coordinates = AbstractTemporalCoordinates.from_df(df) self.coordinates = AbstractTemporalCoordinates.from_df(df)
...@@ -51,14 +52,20 @@ class TestGevTemporalSpline(unittest.TestCase): ...@@ -51,14 +52,20 @@ class TestGevTemporalSpline(unittest.TestCase):
starting_year=None, starting_year=None,
fit_method=self.fit_method) fit_method=self.fit_method)
# Checks that parameters returned are indeed different # Checks that parameters returned are indeed different
mle_params_estimated_year1 = estimator.function_from_fit.get_params(np.array([0])).to_dict() print(self.start_year, self.middle_year, self.last_year)
mle_params_estimated_year3 = estimator.function_from_fit.get_params(np.array([21])).to_dict() mle_params_estimated_year_first = estimator.function_from_fit.get_params(np.array([self.start_year])).to_dict()
mle_params_estimated_year5 = estimator.function_from_fit.get_params(np.array([self.last_year])).to_dict() mle_params_estimated_year_middle = estimator.function_from_fit.get_params(np.array([self.middle_year])).to_dict()
self.assertNotEqual(mle_params_estimated_year1, mle_params_estimated_year3) mle_params_estimated_year_last = estimator.function_from_fit.get_params(np.array([self.last_year])).to_dict()
self.assertNotEqual(mle_params_estimated_year3, mle_params_estimated_year5) self.assertNotEqual(mle_params_estimated_year_first, mle_params_estimated_year_middle)
self.assertNotEqual(mle_params_estimated_year_middle, mle_params_estimated_year_last)
# # Assert the relationship for the location is different between the beginning and the end # # Assert the relationship for the location is different between the beginning and the end
diff1 = mle_params_estimated_year1[param_to_test] - mle_params_estimated_year3[param_to_test] if param_to_test != GevParams.SCALE:
diff2 = mle_params_estimated_year3[param_to_test] - mle_params_estimated_year5[param_to_test] diff1 = mle_params_estimated_year_first[param_to_test] - mle_params_estimated_year_middle[param_to_test]
diff2 = mle_params_estimated_year_middle[param_to_test] - mle_params_estimated_year_last[param_to_test]
else:
# because we use log scaling for the fit, so the relationship is w.r.t. the log of the parameter
diff1 = np.log(mle_params_estimated_year_first[param_to_test]) - np.log(mle_params_estimated_year_middle[param_to_test])
diff2 = np.log(mle_params_estimated_year_middle[param_to_test]) - np.log(mle_params_estimated_year_last[param_to_test])
self.assertNotAlmostEqual(diff1, diff2) self.assertNotAlmostEqual(diff1, diff2)
for idx, nb_year in enumerate(range(5)): for idx, nb_year in enumerate(range(5)):
...@@ -82,9 +89,15 @@ class TestGevTemporalSpline(unittest.TestCase): ...@@ -82,9 +89,15 @@ class TestGevTemporalSpline(unittest.TestCase):
self.function_test_gev_temporal_margin_fit_non_stationary_spline(NonStationaryTwoLinearShapeModel, self.function_test_gev_temporal_margin_fit_non_stationary_spline(NonStationaryTwoLinearShapeModel,
param_to_test=GevParams.SCALE) param_to_test=GevParams.SCALE)
# def test_gev_temporal_margin_fit_spline_two_linear_location_with_added_linearity_in_scale(self): def test_gev_temporal_margin_fit_spline_two_linear_location_with_added_linearity_in_scale(self):
# self.function_test_gev_temporal_margin_fit_non_stationary_spline(NonStationaryTwoLinearLocationOneLinearScaleModel, self.function_test_gev_temporal_margin_fit_non_stationary_spline(NonStationaryTwoLinearLocationOneLinearScaleModel,
# param_to_test=GevParams.SCALE) param_to_test=GevParams.LOC)
def test_gev_temporal_margin_fit_spline_two_linear_location_with_two_linearity_for_the_others(self):
self.function_test_gev_temporal_margin_fit_non_stationary_spline(NonStationaryTwoLinearLocationAndScaleAndShapeModel,
param_to_test=GevParams.SCALE)
if __name__ == '__main__': if __name__ == '__main__':
unittest.main() unittest.main()
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment