.. DO NOT EDIT. .. THIS FILE WAS AUTOMATICALLY GENERATED BY SPHINX-GALLERY. .. TO MAKE CHANGES, EDIT THE SOURCE PYTHON FILE: .. "auto_data_analysis/distribution_fitting/plot_estimate_gev_pirie.py" .. LINE NUMBERS ARE GIVEN BELOW. .. only:: html .. note:: :class: sphx-glr-download-link-note :ref:`Go to the end ` to download the full example code .. rst-class:: sphx-glr-example-title .. _sphx_glr_auto_data_analysis_distribution_fitting_plot_estimate_gev_pirie.py: Estimate a GEV on the Port Pirie sea-levels data ================================================ .. GENERATED FROM PYTHON SOURCE LINES 6-24 In this example, we illustrate various techniques of extreme value modeling applied to the annual maximum sea-levels recorded in Port Pirie, north of Adelaide, south Australia, over the period 1923-1987. Readers should refer to [coles2001]_ to get more details. We illustrate techniques to: - estimate a stationary and a non stationary GEV, - estimate a return level, using: - the log-likelihood function, - the profile log-likelihood function. First, we load the Port pirie dataset of the annual maximum sea-levels. We start by looking at them through time. .. GENERATED FROM PYTHON SOURCE LINES 24-40 .. code-block:: Python import openturns as ot import openturns.viewer as otv import openturns.experimental as otexp from openturns.usecases import coles data = coles.Coles().portpirie print(data[:5]) graph = ot.Graph( "Annual maximum sea-levels at Port Pirie", "year", "level (m)", True, "" ) cloud = ot.Cloud(data[:, :2]) cloud.setColor("red") graph.add(cloud) graph.setIntegerXTick(True) view = otv.View(graph) .. image-sg:: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_001.png :alt: Annual maximum sea-levels at Port Pirie :srcset: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_001.png :class: sphx-glr-single-img .. rst-class:: sphx-glr-script-out .. code-block:: none [ Year SeaLevel ] 0 : [ 1923 4.03 ] 1 : [ 1924 3.83 ] 2 : [ 1925 3.65 ] 3 : [ 1926 3.88 ] 4 : [ 1927 4.01 ] .. GENERATED FROM PYTHON SOURCE LINES 41-42 We select the sea levels column .. GENERATED FROM PYTHON SOURCE LINES 42-44 .. code-block:: Python sample = data[:, 1] .. GENERATED FROM PYTHON SOURCE LINES 45-50 **Stationary GEV modeling via the log-likelihood function** We first assume that the dependence through time is negligible, so we first model the data as independent observations over the observation period. We estimate the parameters of the GEV distribution by maximizing the log-likelihood of the data. .. GENERATED FROM PYTHON SOURCE LINES 50-53 .. code-block:: Python factory = ot.GeneralizedExtremeValueFactory() result_LL = factory.buildMethodOfLikelihoodMaximizationEstimator(sample) .. GENERATED FROM PYTHON SOURCE LINES 54-55 We get the fitted GEV and its parameters of :math:`(\hat{\mu}, \hat{\sigma}, \hat{\xi})`. .. GENERATED FROM PYTHON SOURCE LINES 55-61 .. code-block:: Python fitted_GEV = result_LL.getDistribution() desc = fitted_GEV.getParameterDescription() param = fitted_GEV.getParameter() print(", ".join([f"{p}: {value:.3f}" for p, value in zip(desc, param)])) print("log-likelihood = ", result_LL.getLogLikelihood()) .. rst-class:: sphx-glr-script-out .. code-block:: none mu: 3.875, sigma: 0.198, xi: -0.050 log-likelihood = 4.339057644664945 .. GENERATED FROM PYTHON SOURCE LINES 62-64 We get the asymptotic distribution of the estimator :math:`(\hat{\mu}, \hat{\sigma}, \hat{\xi})`. In that case, the asymptotic distribution is normal. .. GENERATED FROM PYTHON SOURCE LINES 64-68 .. code-block:: Python parameterEstimate = result_LL.getParameterDistribution() print("Asymptotic distribution of the estimator : ") print(parameterEstimate) .. rst-class:: sphx-glr-script-out .. code-block:: none Asymptotic distribution of the estimator : Normal(mu = [3.87477,0.198054,-0.0502339], sigma = [0.0269474,0.0236136,0.132905], R = [[ 1 0.232937 -0.276996 ] [ 0.232937 1 -0.466438 ] [ -0.276996 -0.466438 1 ]]) .. GENERATED FROM PYTHON SOURCE LINES 69-70 We get the covariance matrix and the standard deviation of :math:`(\hat{\mu}, \hat{\sigma}, \hat{\xi})`. .. GENERATED FROM PYTHON SOURCE LINES 70-73 .. code-block:: Python print("Cov matrix = \n", parameterEstimate.getCovariance()) print("Standard dev = ", parameterEstimate.getStandardDeviation()) .. rst-class:: sphx-glr-script-out .. code-block:: none Cov matrix = [[ 0.000726164 0.000148224 -0.000992048 ] [ 0.000148224 0.000557602 -0.00146386 ] [ -0.000992048 -0.00146386 0.0176639 ]] Standard dev = [0.0269474,0.0236136,0.132905] .. GENERATED FROM PYTHON SOURCE LINES 74-75 We get the marginal confidence intervals of order 0.95. .. GENERATED FROM PYTHON SOURCE LINES 75-80 .. code-block:: Python order = 0.95 for i in range(3): ci = parameterEstimate.getMarginal(i).computeBilateralConfidenceInterval(order) print(desc[i] + ":", ci) .. rst-class:: sphx-glr-script-out .. code-block:: none mu: [3.82195, 3.92759] sigma: [0.151772, 0.244336] xi: [-0.310724, 0.210256] .. GENERATED FROM PYTHON SOURCE LINES 81-82 At last, we can validate the inference result thanks the 4 usual diagnostic plots. .. GENERATED FROM PYTHON SOURCE LINES 82-86 .. code-block:: Python validation = otexp.GeneralizedExtremeValueValidation(result_LL, sample) graph = validation.drawDiagnosticPlot() view = otv.View(graph) .. image-sg:: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_002.png :alt: , Sample versus model PP-plot, Sample versus model QQ-plot, Return level plot, Density :srcset: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_002.png :class: sphx-glr-single-img .. GENERATED FROM PYTHON SOURCE LINES 87-90 **Stationary GEV modeling via the profile log-likelihood function** Now, we use the profile log-likehood function rather than log-likehood function to estimate the parameters of the GEV. .. GENERATED FROM PYTHON SOURCE LINES 90-92 .. code-block:: Python result_PLL = factory.buildMethodOfProfileLikelihoodMaximizationEstimator(sample) .. GENERATED FROM PYTHON SOURCE LINES 93-96 The following graph allows one to get the profile log-likelihood plot. It also indicates the optimal value of :math:`\xi`, the maximum profile log-likelihood and the confidence interval for :math:`\xi` of order 0.95 (which is the default value). .. GENERATED FROM PYTHON SOURCE LINES 96-100 .. code-block:: Python order = 0.95 result_PLL.setConfidenceLevel(order) view = otv.View(result_PLL.drawProfileLikelihoodFunction()) .. image-sg:: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_003.png :alt: profile likelihood :srcset: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_003.png :class: sphx-glr-single-img .. GENERATED FROM PYTHON SOURCE LINES 101-106 We can get the numerical values of the confidence interval: it appears to be a bit smaller with the interval obtained from the profile log-likelihood function than with the log-likelihood function. Note that if the order requested is too high, the confidence interval might not be calculated because one of its bound is out of the definition domain of the log-likelihood function. .. GENERATED FROM PYTHON SOURCE LINES 106-112 .. code-block:: Python try: print("Confidence interval for xi = ", result_PLL.getParameterConfidenceInterval()) except Exception as ex: print(type(ex)) pass .. rst-class:: sphx-glr-script-out .. code-block:: none Confidence interval for xi = [-0.218157, 0.170406] .. GENERATED FROM PYTHON SOURCE LINES 113-123 **Return level estimate from the estimated stationary GEV** We estimate the :math:`m`-block return level :math:`z_m`: it is computed as a particular quantile of the GEV model estimated using the log-likelihood function. We just have to use the maximum log-likelihood estimator built in the previous section. As the data are annual sea-levels, each block corresponds to one year: the 10-year return level corresponds to :math:`m=10` and the 100-year return level corresponds to :math:`m=100`. The method also provides the asymptotic distribution of the estimator :math:`\hat{z}_m`. .. GENERATED FROM PYTHON SOURCE LINES 123-136 .. code-block:: Python zm_10 = factory.buildReturnLevelEstimator(result_LL, 10.0) return_level_10 = zm_10.getMean() print("Maximum log-likelihood function : ") print(f"10-year return level = {return_level_10}") return_level_ci10 = zm_10.computeBilateralConfidenceInterval(0.95) print(f"CI = {return_level_ci10}") zm_100 = factory.buildReturnLevelEstimator(result_LL, 100.0) return_level_100 = zm_100.getMean() print(f"100-year return level = {return_level_100}") return_level_ci100 = zm_100.computeBilateralConfidenceInterval(0.95) print(f"CI = {return_level_ci100}") .. rst-class:: sphx-glr-script-out .. code-block:: none Maximum log-likelihood function : 10-year return level = [4.29619] CI = [4.17405, 4.41834] 100-year return level = [4.68824] CI = [4.28031, 5.09616] .. GENERATED FROM PYTHON SOURCE LINES 137-141 **Return level estimate via the profile log-likelihood function of a stationary GEV** We can estimate the :math:`m`-block return level :math:`z_m` directly from the data using the profile likelihood with respect to :math:`z_m`. .. GENERATED FROM PYTHON SOURCE LINES 141-145 .. code-block:: Python result_zm_10_PLL = factory.buildReturnLevelProfileLikelihoodEstimator(sample, 10.0) zm_10_PLL = result_zm_10_PLL.getParameter() print(f"10-year return level (profile) = {zm_10_PLL}") .. rst-class:: sphx-glr-script-out .. code-block:: none 10-year return level (profile) = 4.296169941103285 .. GENERATED FROM PYTHON SOURCE LINES 146-148 We can get the confidence interval of :math:`z_m`: once more, it appears to be a bit smaller than the interval obtained from the log-likelihood function. .. GENERATED FROM PYTHON SOURCE LINES 148-153 .. code-block:: Python result_zm_10_PLL.setConfidenceLevel(0.95) return_level_ci10 = result_zm_10_PLL.getParameterConfidenceInterval() print("Maximum profile log-likelihood function : ") print(f"CI={return_level_ci10}") .. rst-class:: sphx-glr-script-out .. code-block:: none Maximum profile log-likelihood function : CI=[4.20461, 4.44508] .. GENERATED FROM PYTHON SOURCE LINES 154-156 We can also plot the profile log-likelihood function and get the confidence interval, the optimal value of :math:`z_m` and its confidence interval. .. GENERATED FROM PYTHON SOURCE LINES 156-158 .. code-block:: Python view = otv.View(result_zm_10_PLL.drawProfileLikelihoodFunction()) .. image-sg:: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_004.png :alt: profile likelihood :srcset: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_004.png :class: sphx-glr-single-img .. GENERATED FROM PYTHON SOURCE LINES 159-192 **Non stationary GEV modeling via the log-likelihood function** Now, we want to see whether it is necessary to model the time dependence over the observation period. We have to define the functional basis for each parameter of the GEV model. Even if we have the possibility to affect a time-varying model to each of the 3 parameters :math:`(\mu, \sigma, \xi)`, it is strongly recommended not to vary the parameter :math:`\xi`. We suppose that :math:`\mu` is linear with time, and that the other parameters remain constant. For numerical reasons, it is strongly recommended to normalize all the data as follows: .. math:: \tau(t) = \dfrac{t-c}{d} where: - the *CenterReduce* method where :math:`c = \dfrac{1}{n} \sum_{i=1}^n t_i` is the mean time stamps and :math:`d = \sqrt{\dfrac{1}{n} \sum_{i=1}^n (t_i-c)^2}` is the standard deviation of the time stamps; - the *MinMax* method where :math:`c = t_1` is the initial time and :math:`d = t_n-t_1` the final time; - the *None* method where :math:`c = 0` and :math:`d = 1`: in that case, data are not normalized. .. math:: :nowrap: \begin{align*} \mu(t) & = \beta_1 + \beta_2\tau(t) \\ \sigma(t) & = \beta_3 \\ \xi(t) & = \beta_4 \end{align*} .. GENERATED FROM PYTHON SOURCE LINES 192-198 .. code-block:: Python constant = ot.SymbolicFunction(["t"], ["1.0"]) basis_lin = ot.Basis([constant, ot.SymbolicFunction(["t"], ["t"])]) basis_cst = ot.Basis([constant]) # basis for mu, sigma, xi basis_coll = [basis_lin, basis_cst, basis_cst] .. GENERATED FROM PYTHON SOURCE LINES 199-200 We need to get the time stamps (in years here). .. GENERATED FROM PYTHON SOURCE LINES 200-202 .. code-block:: Python timeStamps = data[:, 0] .. GENERATED FROM PYTHON SOURCE LINES 203-215 We can now estimate the list of coefficients :math:`\vect{\beta} = (\beta_1, \beta_2, \beta_3, \beta_4)` using the log-likelihood of the data. We test the 3 normalizing methods and both initial points in order to evaluate their impact on the results. We can see that: - both normalization methods lead to the same result for :math:`\beta_1`, :math:`\beta_3` and :math:`\beta_4` (note that :math:`\beta_2` depends on the normalization function), - both initial points lead to the same result when the data have been normalized, - it is very important to normalize all the data: if not, the result strongly depends on the initial point and it differs from the result obtained with normalized data. The results are not optimal in that case since the associated log-likelihood are much smaller than those obtained with normalized data. .. GENERATED FROM PYTHON SOURCE LINES 215-234 .. code-block:: Python initiPoint_list = list() initiPoint_list.append("Gumbel") initiPoint_list.append("Static") normMethod_list = list() normMethod_list.append("MinMax") normMethod_list.append("CenterReduce") normMethod_list.append("None") print("Linear mu(t) model: ") for normMeth in normMethod_list: for initPoint in initiPoint_list: print("normMeth, initPoint = ", normMeth, initPoint) # The ot.Function() is the identity function. result = factory.buildTimeVarying( sample, timeStamps, basis_coll, ot.Function(), initPoint, normMeth ) beta = result.getOptimalParameter() print("beta1, beta2, beta3, beta4 = ", beta) print("Max log-likelihood = ", result.getLogLikelihood()) .. rst-class:: sphx-glr-script-out .. code-block:: none Linear mu(t) model: normMeth, initPoint = MinMax Gumbel beta1, beta2, beta3, beta4 = [3.88617,-0.0226606,0.197965,-0.050304] Max log-likelihood = 4.375105790428855 normMeth, initPoint = MinMax Static beta1, beta2, beta3, beta4 = [3.88616,-0.022621,0.197965,-0.0504251] Max log-likelihood = 4.375106565819115 normMeth, initPoint = CenterReduce Gumbel beta1, beta2, beta3, beta4 = [3.87484,-0.00671465,0.197963,-0.0503351] Max log-likelihood = 4.375106360823884 normMeth, initPoint = CenterReduce Static beta1, beta2, beta3, beta4 = [3.87484,-0.00670763,0.197954,-0.0503005] Max log-likelihood = 4.375105770154065 normMeth, initPoint = None Gumbel beta1, beta2, beta3, beta4 = [3.89541,-1.63808e-05,0.197743,0.100071] Max log-likelihood = 3.3473631512726687 normMeth, initPoint = None Static beta1, beta2, beta3, beta4 = [3.87477,-3.43115e-10,0.198052,-0.0502339] Max log-likelihood = 4.339057650029008 .. GENERATED FROM PYTHON SOURCE LINES 235-237 According to the previous results, we choose the *MinMax* normalization method and the *Gumbel* initial point. This initial point is cheaper than the *Static* one as it requires no optimization computation. .. GENERATED FROM PYTHON SOURCE LINES 237-245 .. code-block:: Python result_NonStatLL = factory.buildTimeVarying(sample, timeStamps, basis_coll) beta = result_NonStatLL.getOptimalParameter() print("beta1, beta2, beta3, beta_4 = ", beta) print(f"mu(t) = {beta[0]:.4f} + {beta[1]:.4f} * tau") print(f"sigma = {beta[2]:.4f}") print(f"xi = {beta[3]:.4f}") .. rst-class:: sphx-glr-script-out .. code-block:: none beta1, beta2, beta3, beta_4 = [3.88617,-0.0226606,0.197965,-0.050304] mu(t) = 3.8862 + -0.0227 * tau sigma = 0.1980 xi = -0.0503 .. GENERATED FROM PYTHON SOURCE LINES 246-248 We get the asymptotic distribution of :math:`\vect{\beta}` to compute some confidence intervals of the estimates, for example of order :math:`p = 0.95`. .. GENERATED FROM PYTHON SOURCE LINES 248-267 .. code-block:: Python dist_beta = result_NonStatLL.getParameterDistribution() condifence_level = 0.95 for i in range(beta.getSize()): lower_bound = dist_beta.getMarginal(i).computeQuantile((1 - condifence_level) / 2)[ 0 ] upper_bound = dist_beta.getMarginal(i).computeQuantile((1 + condifence_level) / 2)[ 0 ] print( "Conf interval for beta_" + str(i + 1) + " = [" + str(lower_bound) + "; " + str(upper_bound) + "]" ) .. rst-class:: sphx-glr-script-out .. code-block:: none Conf interval for beta_1 = [3.7819584050572863; 3.9903750065231987] Conf interval for beta_2 = [-0.20104848968405; 0.1557273437381724] Conf interval for beta_3 = [0.151332979948103; 0.24459660690371385] Conf interval for beta_4 = [-0.3155923201112344; 0.21498426739122067] .. GENERATED FROM PYTHON SOURCE LINES 268-269 You can get the expression of the normalizing function :math:`t \mapsto \tau(t)`: .. GENERATED FROM PYTHON SOURCE LINES 269-274 .. code-block:: Python normFunc = result_NonStatLL.getNormalizationFunction() print("Function tau(t): ", normFunc) print("c = ", normFunc.getEvaluation().getImplementation().getCenter()[0]) print("1/d = ", normFunc.getEvaluation().getImplementation().getLinear()[0, 0]) .. rst-class:: sphx-glr-script-out .. code-block:: none Function tau(t): class=LinearFunction name=Unnamed implementation=class=LinearEvaluation name=Unnamed center=[1923] constant=[0] linear=[[ 0.015625 ]] c = 1923.0 1/d = 0.015625 .. GENERATED FROM PYTHON SOURCE LINES 275-277 You can get the function :math:`t \mapsto \vect{\theta}(t)` where :math:`\vect{\theta}(t) = (\mu(t), \sigma(t), \xi(t))`. .. GENERATED FROM PYTHON SOURCE LINES 277-279 .. code-block:: Python functionTheta = result_NonStatLL.getParameterFunction() .. GENERATED FROM PYTHON SOURCE LINES 280-283 In order to compare different modelings, we get the optimal log-likelihood of the data for both stationary and non stationary models. The difference seems to be non significant enough, which means that the non stationary model does not really improve the quality of the modeling. .. GENERATED FROM PYTHON SOURCE LINES 283-287 .. code-block:: Python print("Max log-likelihood: ") print("Stationary model = ", result_LL.getLogLikelihood()) print("Non stationary linear mu(t) model = ", result_NonStatLL.getLogLikelihood()) .. rst-class:: sphx-glr-script-out .. code-block:: none Max log-likelihood: Stationary model = 4.339057644664945 Non stationary linear mu(t) model = 4.375105790428855 .. GENERATED FROM PYTHON SOURCE LINES 288-307 In order to draw some diagnostic plots similar to those drawn in the stationary case, we refer to the following result: if :math:`Z_t` is a non stationary GEV model parametrized by :math:`(\mu(t), \sigma(t), \xi(t))`, then the standardized variables :math:`\hat{Z}_t` defined by: .. math:: \hat{Z}_t = \dfrac{1}{\xi(t)} \log \left[1+ \xi(t)\left( \dfrac{Z_t-\mu(t)}{\sigma(t)} \right)\right] have the standard Gumbel distribution which is the GEV model with :math:`(\mu, \sigma, \xi) = (0, 1, 0)`. As a result, we can validate the inference result thanks the 4 usual diagnostic plots: - the probability-probability pot, - the quantile-quantile pot, - the return level plot, - the data histogram and the desnity of the fitted model. using the transformed data compared to the Gumbel model. We can see that the adequation seems similar to the graph of the stationary model. .. GENERATED FROM PYTHON SOURCE LINES 307-310 .. code-block:: Python graph = result_NonStatLL.drawDiagnosticPlot() view = otv.View(graph) .. image-sg:: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_005.png :alt: , Sample versus model PP-plot, Sample versus model QQ-plot, Return level plot, Density :srcset: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_005.png :class: sphx-glr-single-img .. GENERATED FROM PYTHON SOURCE LINES 311-329 We can draw the mean function :math:`t \mapsto \Expect{\mbox{GEV}(t)}`. Be careful, it is not the function :math:`t \mapsto \mu(t)`. As a matter of fact, the mean is defined for :math:`\xi <1` only and in that case, for :math:`\xi \neq 0`, we have: .. math:: \Expect{\mbox{GEV}(t)} = \mu(t) + \dfrac{\sigma(t)}{\xi(t)} (\Gamma(1-\xi(t))-1) and for :math:`\xi = 0`, we have: .. math:: \Expect{\mbox{GEV}(t)} = \mu(t) + \sigma(t)\gamma where :math:`\gamma` is the Euler constant. We can also draw the function :math:`t \mapsto q_p(t)` where :math:`q_p(t)` is the quantile of order :math:`p` of the GEV distribution at time :math:`t`. Here, :math:`\mu(t)` is a linear function and the other parameters are constant, so the mean and the quantile functions are also linear functions. .. GENERATED FROM PYTHON SOURCE LINES 329-357 .. code-block:: Python graph = ot.Graph( r"Maximum annual sea-levels at Port Pirie - Linear $\mu(t)$", "year", "level (m)", True, "", ) graph.setIntegerXTick(True) # data cloud = ot.Cloud(data[:, :2]) cloud.setColor("red") graph.add(cloud) # mean function meandata = [ result_NonStatLL.getDistribution(t).getMean()[0] for t in data[:, 0].asPoint() ] curve_meanPoints = ot.Curve(data[:, 0].asPoint(), meandata) graph.add(curve_meanPoints) # quantile function graphQuantile = result_NonStatLL.drawQuantileFunction(0.95) drawQuant = graphQuantile.getDrawable(0) drawQuant = graphQuantile.getDrawable(0) drawQuant.setLineStyle("dashed") graph.add(drawQuant) graph.setLegends(["data", "mean function", "quantile 0.95 function"]) graph.setLegendPosition("lower right") view = otv.View(graph) .. image-sg:: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_006.png :alt: Maximum annual sea-levels at Port Pirie - Linear $\mu(t)$ :srcset: /auto_data_analysis/distribution_fitting/images/sphx_glr_plot_estimate_gev_pirie_006.png :class: sphx-glr-single-img .. GENERATED FROM PYTHON SOURCE LINES 358-368 At last, we can test the validity of the stationary model :math:`\mathcal{M}_0` relative to the model with time varying parameters :math:`\mathcal{M}_1`. The model :math:`\mathcal{M}_0` is parametrized by :math:`(\beta_1, \beta_3, \beta_4)` and the model :math:`\mathcal{M}_1` is parametrized by :math:`(\beta_1, \beta_2, \beta_3, \beta_4)`: so we have :math:`\mathcal{M}_0 \subset \mathcal{M}_1`. We use the Likelihood Ratio test. The null hypothesis is the stationary model :math:`\mathcal{M}_0`. The Type I error :math:`\alpha` is taken equal to 0.05. This test confirms that there is no evidence of a linear trend for :math:`\mu`. .. GENERATED FROM PYTHON SOURCE LINES 368-380 .. code-block:: Python llh_LL = result_LL.getLogLikelihood() llh_NonStatLL = result_NonStatLL.getLogLikelihood() modelM0_Nb_param = 3 modelM1_Nb_param = 4 resultLikRatioTest = ot.HypothesisTest.LikelihoodRatioTest( modelM0_Nb_param, llh_LL, modelM1_Nb_param, llh_NonStatLL, 0.05 ) accepted = resultLikRatioTest.getBinaryQualityMeasure() print( f"Hypothesis H0 (stationary model) vs H1 (linear mu(t) model): accepted ? = {accepted}" ) .. rst-class:: sphx-glr-script-out .. code-block:: none Hypothesis H0 (stationary model) vs H1 (linear mu(t) model): accepted ? = True .. GENERATED FROM PYTHON SOURCE LINES 381-385 We detail the statistics of the Likelihood Ratio test: the deviance statistics :math:`\mathcal{D}_p` follows a :math:`\chi^2_1` distribution. The model :math:`\mathcal{M}_0` is rejected if the deviance statistics estimated on the data is greater than the threshold :math:`c_{\alpha}` or if the p-value is less than the Type I error :math:`\alpha = 0.05`. .. GENERATED FROM PYTHON SOURCE LINES 385-389 .. code-block:: Python print(f"Dp={resultLikRatioTest.getStatistic():.2f}") print(f"alpha={resultLikRatioTest.getThreshold():.2f}") print(f"p-value={resultLikRatioTest.getPValue():.2f}") .. rst-class:: sphx-glr-script-out .. code-block:: none Dp=0.07 alpha=0.05 p-value=0.79 .. GENERATED FROM PYTHON SOURCE LINES 390-391 .. code-block:: Python otv.View.ShowAll() .. _sphx_glr_download_auto_data_analysis_distribution_fitting_plot_estimate_gev_pirie.py: .. only:: html .. container:: sphx-glr-footer sphx-glr-footer-example .. container:: sphx-glr-download sphx-glr-download-jupyter :download:`Download Jupyter notebook: plot_estimate_gev_pirie.ipynb ` .. container:: sphx-glr-download sphx-glr-download-python :download:`Download Python source code: plot_estimate_gev_pirie.py `