def ppf( self, pits: Union[Sequence[float], ArrayLike1D], parameters: Optional[Union[Sequence[float], ArrayLike1D]] = None, ) -> NDArray: parameters = self._check_constraints(parameters) pits = asarray(pits) nu = parameters[0] var = stats.gennorm(nu).var() return stats.gennorm(nu, scale=1.0 / sqrt(var)).ppf(pits)
def cdf( self, resids: ArrayLike, parameters: Optional[Union[Sequence[float], ArrayLike1D]] = None, ) -> NDArray: parameters = self._check_constraints(parameters) nu = parameters[0] var = stats.gennorm(nu).var() resids = asarray(resids) return stats.gennorm(nu, scale=1.0 / sqrt(var)).cdf(resids)
def dist_test(log, conf_level = 0.95, dist = 'normal'): # test for normal if dist == 'normal': rv = norm(loc = np.mean(log), scale = np.std(log, ddof = 1)) test = kstest(log, rv.cdf) D_crit = 1.3581/np.sqrt(len(log)) # test result if test[0] > D_crit or test[1] < 1 - conf_level: result = False else: result = True return result # test for ged elif dist == 'ged': beta = 1.3 log2 = [abs(x)**beta for x in log] scale = (np.mean(log2)*beta)**(1/beta) rv = gennorm(beta = beta, scale = scale) D_crit = 1.3581/np.sqrt(len(log)) #test result if test[0] > D_crit or test[1] < 1 - conf_level: result = False else: result = True return result else: return None
def ind_risk(self, method = 'norm', start = year_1, end = today, conf_level = 0.95, beta = 1.3, expo = 0.94): """ Common methods include: - "norm": Normal (Guassian) with 1 year period, 60 days periods, 30 days periods - "student": T of Student with 60 days periods, 30 days periods - Generalized Error with 1 year period, 60 days periods, 30 days periods Inform BETA - EWMA with lambda = 0.94 or lambda = 0.97 Inform factor - Level of Confidence = 0.95 or 0.99 """ if method == 'norm': df = self.data df = df[df.index >= start] df = df[df.index <= end] R = df['return'].mean() S = np.std(df['return'], ddof = 1) rv = norm(loc = R, scale = S) var = rv.ppf(1 - conf_level) return var elif method == 'student': df = self.data df = df[df.index >= start] df = df[df.index <= end] R = df['return'].mean() S = np.std(df['return'], ddof = 1) rv = t(loc = R, scale = S, df = df.shape[0] - 1) var = rv.ppf(1 - conf_level) return var elif method == 'ged': df = self.data df = df[df.index >= start] df = df[df.index <= end] log = df['return'] log2 = [abs(x)**beta for x in log] scale = (np.mean(log2)*beta)**(1/beta) rv = gennorm(beta = beta, scale = scale) var = rv.ppf(1 - conf_level) return var elif method == 'ewma': df = self.data df = df[df.index <= end] log = df['return'] log = pd.DataFrame(log) index = list(log.index) log['factor'] = [len(index) - index.index(d) - 1 for d in log.index] log['weight'] = (1-expo)*(expo**log['factor']) log['ewma_return'] = log['return']*log['weight'] log['ewma_std'] = (log['return']**2)*log['weight'] R = log['ewma_return'].sum() S = np.sqrt(log['ewma_std'].sum()) rv = norm(loc = R, scale = S) var = rv.ppf(1 - conf_level) return var else: print('Undefined Method') return None
def testGeneralizedNormalLogCDF(self): if self.dtype is np.float32: self.skipTest('32-bit precision not sufficient for LogCDF') batch_size = 50 mu = self._rng.randn(batch_size) sigma = self._rng.rand(batch_size) + 1. power = self._rng.rand(batch_size) + 1. x = np.linspace(-100., 10., batch_size).astype(np.float64) gnormal = tfd.GeneralizedNormal(loc=self.make_input(mu), scale=self.make_input(sigma), power=self.make_input(power), validate_args=True) cdf = gnormal.log_cdf(x) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), cdf.shape) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), self.evaluate(cdf).shape) self.assertAllEqual(gnormal.batch_shape, cdf.shape) self.assertAllEqual(gnormal.batch_shape, self.evaluate(cdf).shape) expected_cdf = sp_stats.gennorm(power, loc=mu, scale=sigma).logcdf(x) self.assertAllClose(expected_cdf, self.evaluate(cdf), atol=0, rtol=1e-3)
def test_rbf(): key1, key2 = random.split(random.PRNGKey(0), 2) x = np.arange(8).reshape(-1, 1) tests = [] for ls in np.linspace(0.9, 2., 5): gauss_ref = norm(loc=0., scale=ls) lapl_ref = laplace(loc=0., scale=ls) tests.append( (f"Gauss_sc_{ls}", GenGaussKernel.make_gauss(length_scale=ls), gauss_ref.var(), gauss_ref.pdf(x))) tests.append( (f"Lapl_sc_{ls}", GenGaussKernel.make_laplace(length_scale=ls), lapl_ref.var(), lapl_ref.pdf(x))) for shape in np.linspace(0.9, 2., 5): gg_ref = gennorm(beta=shape, scale=ls) tests.append((f"GG__sh_{shape}__sc_{ls}", GenGaussKernel.make(shape=shape, length_scale=ls), gg_ref.var(), gg_ref.pdf(x))) for (n, k, v, pdf) in tests: #print(n) assert np.abs(v - k.var()) < 1e-4, f"{n}: {v} != {k.var()}" g = k(x) assert np.allclose(pdf.squeeze(), g[0, :], atol=1e-1)
def adjust_noise(optimizer, epoch, args, noise_dict): keys = list(noise_dict.keys()) keys.sort() select = keys[0] for k in keys: select = k if k > epoch: break if args.noisemodel == 'johnson': noise_model = st.johnsonsu(*noise_dict[select]) if args.noisemodel == 'gaussian': print("GAUSSIAN NOISE set") noise_model = st.norm(*noise_dict[select]) if args.noisemodel == 'laplace': noise_model = st.laplace(*noise_dict[select]) if args.noisemodel == 'cauchy': noise_model = st.cauchy(*noise_dict[select]) if args.noisemodel == 'gennorm': noise_model = st.gennorm(*noise_dict[select]) if args.noisemodel == 'studentt': noise_model = st.t(*noise_dict[select]) print('noise model is', args.noisemodel, noise_dict[select]) optimizer.noise_generator = noise_model
def partial_moment(self, n, z=0, parameters=None): parameters = self._check_constraints(parameters) nu = parameters[0] scale = 1. / sqrt(stats.gennorm(nu).var()) moment = (scale**n) * self._ord_gennorm_partial_moment( n, z / scale, nu) return moment
def testGeneralizedNormalLogPDF(self): batch_size = 6 mu = tf.constant([3.] * batch_size, dtype=self.dtype) sigma = tf.constant([math.sqrt(10.)] * batch_size, dtype=self.dtype) power = tf.constant([4.] * batch_size, dtype=self.dtype) x = np.array([-2.5, 2.5, 4., 0., -1., 2.], dtype=np.float32) gnormal = tfd.GeneralizedNormal(loc=mu, scale=sigma, power=power, validate_args=True) log_pdf = gnormal.log_prob(x) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), log_pdf.shape) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), self.evaluate(log_pdf).shape) self.assertAllEqual(gnormal.batch_shape, log_pdf.shape) self.assertAllEqual(gnormal.batch_shape, self.evaluate(log_pdf).shape) pdf = gnormal.prob(x) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), pdf.shape) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), self.evaluate(pdf).shape) self.assertAllEqual(gnormal.batch_shape, pdf.shape) self.assertAllEqual(gnormal.batch_shape, self.evaluate(pdf).shape) expected_log_pdf = sp_stats.gennorm( self.evaluate(power), loc=self.evaluate(mu), scale=self.evaluate(sigma)).logpdf(x) self.assertAllClose(expected_log_pdf, self.evaluate(log_pdf)) self.assertAllClose(np.exp(expected_log_pdf), self.evaluate(pdf))
def moment(self, n, parameters=None): if n < 0: return nan parameters = self._check_constraints(parameters) nu = parameters[0] var = stats.gennorm(nu).var() return stats.gennorm.moment(n, nu, scale=1. / sqrt(var))
def obj(s, args=None): """args = [min, max, beta, ppf]""" loc = (args[1]+args[0])/2. beta = args[2] ppf = args[3] d = gennorm(loc=loc, scale=s, beta=beta) r = sum((d.ppf([1.-ppf, .5, ppf]) - np.array([args[0], loc, args[1]]))**2) return r
def moment( self, n: int, parameters: Optional[Union[Sequence[float], ArrayLike1D]] = None ) -> float: if n < 0: return nan parameters = self._check_constraints(parameters) nu = parameters[0] var = stats.gennorm(nu).var() return stats.gennorm.moment(n, nu, scale=1.0 / sqrt(var))
def partial_moment( self, n: int, z: float = 0.0, parameters: Optional[Union[Sequence[float], ArrayLike1D]] = None, ) -> float: parameters = self._check_constraints(parameters) nu = parameters[0] scale = 1.0 / sqrt(stats.gennorm(nu).var()) moment = (scale ** n) * self._ord_gennorm_partial_moment(n, z / scale, nu) return moment
def __init__(self, loc, scale, beta, validate_args=None): self.loc, self.scale = broadcast_all(loc, scale) (self.beta, ) = broadcast_all(beta) self.scipy_dist = stats.gennorm( loc=self.loc.cpu().detach().numpy(), scale=self.scale.cpu().detach().numpy(), beta=self.beta.cpu().detach().numpy()) if isinstance(loc, Number) and isinstance(scale, Number): batch_shape = torch.Size() else: batch_shape = self.loc.size() super(GeneralizedNormal, self).__init__(batch_shape, validate_args=validate_args)
def distr(self): def obj(s, args=None): """args = [min, max, beta, ppf]""" loc = (args[1]+args[0])/2. beta = args[2] ppf = args[3] d = gennorm(loc=loc, scale=s, beta=beta) r = sum((d.ppf([1.-ppf, .5, ppf]) - np.array([args[0], loc, args[1]]))**2) return r if self._distr is None: from scipy.optimize import minimize res = minimize(obj, [.1], method='Nelder-Mead', tol=1e-6, args=[self.clip[0],self.clip[1], self.beta, .999]) # res = scipy.optimize.minimize_scalar(obj, bounds=[1e-10, 1], args=[1.,4., beta, .999], tol=1e-10) # print("res", res.x) self._distr = gennorm(loc=self.mean, scale=res.x, beta=self.beta) return self._distr
def eval_generalized_normal_logpdf(eval_at, mu=0.0, alpha=1.0, p=10.0, lower=-np.inf, upper=np.inf): """Evaluate the generalized normal pdf, scaled/shifted See `sample_generalized_normal` for parameter definitions. """ generalized_normal = stats.gennorm(beta=p, loc=mu, scale=alpha) unnormed_eval_logpdf = generalized_normal.logpdf(eval_at) unnormed_eval_logpdf[eval_at < lower] = -np.inf unnormed_eval_logpdf[eval_at > upper] = -np.inf accept_norm = generalized_normal.cdf(upper) - generalized_normal.cdf(lower) normed_eval_logpdf = unnormed_eval_logpdf - np.log(accept_norm) return normed_eval_logpdf
def testGeneralizedNormalEntropyWithScalarInputs(self): loc_v = 2.34 scale_v = 4.56 power_v = 7.89 gnormal = tfd.GeneralizedNormal(loc=self.make_input(loc_v), scale=self.make_input(scale_v), power=self.make_input(power_v), validate_args=True) entropy = gnormal.entropy() self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), entropy.shape) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), self.evaluate(entropy).shape) self.assertAllEqual(gnormal.batch_shape, entropy.shape) self.assertAllEqual(gnormal.batch_shape, self.evaluate(entropy).shape) expected_entropy = sp_stats.gennorm(power_v, loc=loc_v, scale=scale_v).entropy() self.assertAllClose(expected_entropy, self.evaluate(entropy))
def sample_generalized_normal(self, mu=0.0, alpha=1.0, p=10.0, lower=-np.inf, upper=np.inf): """Samples from a generalized normal distribution, optionally truncated Note ---- Also called the exponential power distribution, this distribution converges pointwise to uniform as p --> infinity. To approximate a uniform between ``a`` and ``b``, define ``mu = 0.5*(a + b)`` and ``alpha=0.5*(b - a)``. For ``p=1``, it's identical to Laplace. For ``p=2``, it's identical to normal. See [1]_. Parameters ---------- mu : float location (default: 0.0) alpha : float scale (default: 1.0) p : float shape (default: 10.0) lower : float min value (default: -np.inf) upper : float max value (default: np.inf) References ---------- .. [1] `"Generalized normal distribution, Version 1" <https://en.wikipedia.org/wiki/Generalized_normal_distribution#Version_1>`_ """ generalized_normal = stats.gennorm(beta=p, loc=mu, scale=alpha) sample = generalized_normal.rvs() # Reject samples outside of bounds, repeat sampling until accepted while not np.all( [np.greater(sample, lower), np.greater(upper, sample)]): sample = generalized_normal.rvs() return sample
def testGeneralizedNormalSF(self): batch_size = 50 mu = self._rng.randn(batch_size) sigma = self._rng.rand(batch_size) + 1. power = self._rng.rand(batch_size) + 1. x = np.linspace(-8., 8., batch_size).astype(np.float64) gnormal = tfd.GeneralizedNormal(loc=self.make_input(mu), scale=self.make_input(sigma), power=self.make_input(power), validate_args=True) sf = gnormal.survival_function(x) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), sf.shape) self.assertAllEqual(self.evaluate(gnormal.batch_shape_tensor()), self.evaluate(sf).shape) self.assertAllEqual(gnormal.batch_shape, sf.shape) self.assertAllEqual(gnormal.batch_shape, self.evaluate(sf).shape) expected_sf = sp_stats.gennorm(power, loc=mu, scale=sigma).sf(x) self.assertAllClose(expected_sf, self.evaluate(sf), atol=0, rtol=1e-5)
def testGeneralizedNormalQuantile(self): batch_size = 50 mu = self._rng.randn(batch_size) sigma = self._rng.rand(batch_size) + 1. power = self._rng.rand(batch_size) + 1. p = np.linspace(0., 1., batch_size).astype(np.float64) gnormal = tfd.GeneralizedNormal(loc=self.make_input(mu), scale=self.make_input(sigma), power=self.make_input(power), validate_args=True) quantile = gnormal.quantile(p) self.assertAllEqual( self.evaluate(gnormal.batch_shape_tensor()), quantile.shape) self.assertAllEqual( self.evaluate(gnormal.batch_shape_tensor()), self.evaluate(quantile).shape) self.assertAllEqual(gnormal.batch_shape, quantile.shape) self.assertAllEqual(gnormal.batch_shape, self.evaluate(quantile).shape) expected_quantile = sp_stats.gennorm(power, loc=mu, scale=sigma).ppf(p) self.assertAllClose( expected_quantile, self.evaluate(quantile), atol=0, rtol=1e-4)
if args.noisemodel == 'johnson': noise_model = st.johnsonsu(*args.noiseparams) if args.noisemodel == 'gaussian': noise_model = st.norm(*args.noiseparams) if args.noisemodel == 'laplace': noise_model = st.laplace(*args.noiseparams) if args.noisemodel == 'cauchy': noise_model = st.cauchy(*args.noiseparams) if args.noisemodel == 'gennorm': noise_model = st.gennorm(*args.noiseparams) if args.noisemodel == 'studentt': noise_model = st.t(*args.noiseparams) def adjust_learning_rate(optimizer, epoch): """Sets the learning rate to the initial LR decayed by 10 every 30 epochs""" lr = 0.16 if epoch > 10: lr = 0.07 if epoch > 20: lr = 0.05 if epoch > 30: lr = 0.03
def cdf(self, resids, parameters=None): self._check_constraints(parameters) nu = parameters[0] var = stats.gennorm(nu).var() return stats.gennorm(nu, scale=1.0 / sqrt(var)).cdf(resids)
def ppf(self, pits, parameters=None): self._check_constraints(parameters) nu = parameters[0] var = stats.gennorm(nu).var() return stats.gennorm(nu, scale=1.0 / sqrt(var)).ppf(pits)
def ppf(self, pits, parameters=None): self._check_constraints(parameters) pits = asarray(pits) nu = parameters[0] var = stats.gennorm(nu).var() return stats.gennorm(nu, scale=1.0 / sqrt(var)).ppf(pits)
ax.margins(x=0, y=0) if line: ax.plot(np.linspace(0, 1), np.linspace(0, 1), 'r', lw=2) return ax ## Gráfico pp distribución completa fig, ((ax1,ax2),(ax3,ax4)) = plt.subplots(nrows = 2, ncols = 2, dpi=1300) pp_plot(logeados, stats.gennorm(beta = parametros_normal[0], loc = parametros_normal[1], scale=parametros_normal[2]), line = True, ax=ax1) ax1.set_title('Normal generalizada', fontsize=11) pp_plot(logeados, stats.genpareto(c = parametros_pareto[0], loc = parametros_pareto[1], scale=parametros_pareto[2]), line = True,ax=ax2) ax2.set_title('Pareto generalizada', fontsize=11) pp_plot(logeados, stats.dweibull(c = parametros_weibull[0], loc = parametros_weibull[1], scale=parametros_weibull[2]),
def all_dists(): # dists param were taken from scipy.stats official # documentaion examples # Total - 89 return { "alpha": stats.alpha(a=3.57, loc=0.0, scale=1.0), "anglit": stats.anglit(loc=0.0, scale=1.0), "arcsine": stats.arcsine(loc=0.0, scale=1.0), "beta": stats.beta(a=2.31, b=0.627, loc=0.0, scale=1.0), "betaprime": stats.betaprime(a=5, b=6, loc=0.0, scale=1.0), "bradford": stats.bradford(c=0.299, loc=0.0, scale=1.0), "burr": stats.burr(c=10.5, d=4.3, loc=0.0, scale=1.0), "cauchy": stats.cauchy(loc=0.0, scale=1.0), "chi": stats.chi(df=78, loc=0.0, scale=1.0), "chi2": stats.chi2(df=55, loc=0.0, scale=1.0), "cosine": stats.cosine(loc=0.0, scale=1.0), "dgamma": stats.dgamma(a=1.1, loc=0.0, scale=1.0), "dweibull": stats.dweibull(c=2.07, loc=0.0, scale=1.0), "erlang": stats.erlang(a=2, loc=0.0, scale=1.0), "expon": stats.expon(loc=0.0, scale=1.0), "exponnorm": stats.exponnorm(K=1.5, loc=0.0, scale=1.0), "exponweib": stats.exponweib(a=2.89, c=1.95, loc=0.0, scale=1.0), "exponpow": stats.exponpow(b=2.7, loc=0.0, scale=1.0), "f": stats.f(dfn=29, dfd=18, loc=0.0, scale=1.0), "fatiguelife": stats.fatiguelife(c=29, loc=0.0, scale=1.0), "fisk": stats.fisk(c=3.09, loc=0.0, scale=1.0), "foldcauchy": stats.foldcauchy(c=4.72, loc=0.0, scale=1.0), "foldnorm": stats.foldnorm(c=1.95, loc=0.0, scale=1.0), # "frechet_r": stats.frechet_r(c=1.89, loc=0.0, scale=1.0), # "frechet_l": stats.frechet_l(c=3.63, loc=0.0, scale=1.0), "genlogistic": stats.genlogistic(c=0.412, loc=0.0, scale=1.0), "genpareto": stats.genpareto(c=0.1, loc=0.0, scale=1.0), "gennorm": stats.gennorm(beta=1.3, loc=0.0, scale=1.0), "genexpon": stats.genexpon(a=9.13, b=16.2, c=3.28, loc=0.0, scale=1.0), "genextreme": stats.genextreme(c=-0.1, loc=0.0, scale=1.0), "gausshyper": stats.gausshyper(a=13.8, b=3.12, c=2.51, z=5.18, loc=0.0, scale=1.0), "gamma": stats.gamma(a=1.99, loc=0.0, scale=1.0), "gengamma": stats.gengamma(a=4.42, c=-3.12, loc=0.0, scale=1.0), "genhalflogistic": stats.genhalflogistic(c=0.773, loc=0.0, scale=1.0), "gilbrat": stats.gilbrat(loc=0.0, scale=1.0), "gompertz": stats.gompertz(c=0.947, loc=0.0, scale=1.0), "gumbel_r": stats.gumbel_r(loc=0.0, scale=1.0), "gumbel_l": stats.gumbel_l(loc=0.0, scale=1.0), "halfcauchy": stats.halfcauchy(loc=0.0, scale=1.0), "halflogistic": stats.halflogistic(loc=0.0, scale=1.0), "halfnorm": stats.halfnorm(loc=0.0, scale=1.0), "halfgennorm": stats.halfgennorm(beta=0.675, loc=0.0, scale=1.0), "hypsecant": stats.hypsecant(loc=0.0, scale=1.0), "invgamma": stats.invgamma(a=4.07, loc=0.0, scale=1.0), "invgauss": stats.invgauss(mu=0.145, loc=0.0, scale=1.0), "invweibull": stats.invweibull(c=10.6, loc=0.0, scale=1.0), "johnsonsb": stats.johnsonsb(a=4.32, b=3.18, loc=0.0, scale=1.0), "johnsonsu": stats.johnsonsu(a=2.55, b=2.25, loc=0.0, scale=1.0), "ksone": stats.ksone(n=1e03, loc=0.0, scale=1.0), "kstwobign": stats.kstwobign(loc=0.0, scale=1.0), "laplace": stats.laplace(loc=0.0, scale=1.0), "levy": stats.levy(loc=0.0, scale=1.0), "levy_l": stats.levy_l(loc=0.0, scale=1.0), "levy_stable": stats.levy_stable(alpha=0.357, beta=-0.675, loc=0.0, scale=1.0), "logistic": stats.logistic(loc=0.0, scale=1.0), "loggamma": stats.loggamma(c=0.414, loc=0.0, scale=1.0), "loglaplace": stats.loglaplace(c=3.25, loc=0.0, scale=1.0), "lognorm": stats.lognorm(s=0.954, loc=0.0, scale=1.0), "lomax": stats.lomax(c=1.88, loc=0.0, scale=1.0), "maxwell": stats.maxwell(loc=0.0, scale=1.0), "mielke": stats.mielke(k=10.4, s=3.6, loc=0.0, scale=1.0), "nakagami": stats.nakagami(nu=4.97, loc=0.0, scale=1.0), "ncx2": stats.ncx2(df=21, nc=1.06, loc=0.0, scale=1.0), "ncf": stats.ncf(dfn=27, dfd=27, nc=0.416, loc=0.0, scale=1.0), "nct": stats.nct(df=14, nc=0.24, loc=0.0, scale=1.0), "norm": stats.norm(loc=0.0, scale=1.0), "pareto": stats.pareto(b=2.62, loc=0.0, scale=1.0), "pearson3": stats.pearson3(skew=0.1, loc=0.0, scale=1.0), "powerlaw": stats.powerlaw(a=1.66, loc=0.0, scale=1.0), "powerlognorm": stats.powerlognorm(c=2.14, s=0.446, loc=0.0, scale=1.0), "powernorm": stats.powernorm(c=4.45, loc=0.0, scale=1.0), "rdist": stats.rdist(c=0.9, loc=0.0, scale=1.0), "reciprocal": stats.reciprocal(a=0.00623, b=1.01, loc=0.0, scale=1.0), "rayleigh": stats.rayleigh(loc=0.0, scale=1.0), "rice": stats.rice(b=0.775, loc=0.0, scale=1.0), "recipinvgauss": stats.recipinvgauss(mu=0.63, loc=0.0, scale=1.0), "semicircular": stats.semicircular(loc=0.0, scale=1.0), "t": stats.t(df=2.74, loc=0.0, scale=1.0), "triang": stats.triang(c=0.158, loc=0.0, scale=1.0), "truncexpon": stats.truncexpon(b=4.69, loc=0.0, scale=1.0), "truncnorm": stats.truncnorm(a=0.1, b=2, loc=0.0, scale=1.0), "tukeylambda": stats.tukeylambda(lam=3.13, loc=0.0, scale=1.0), "uniform": stats.uniform(loc=0.0, scale=1.0), "vonmises": stats.vonmises(kappa=3.99, loc=0.0, scale=1.0), "vonmises_line": stats.vonmises_line(kappa=3.99, loc=0.0, scale=1.0), "wald": stats.wald(loc=0.0, scale=1.0), "weibull_min": stats.weibull_min(c=1.79, loc=0.0, scale=1.0), "weibull_max": stats.weibull_max(c=2.87, loc=0.0, scale=1.0), "wrapcauchy": stats.wrapcauchy(c=0.0311, loc=0.0, scale=1.0), }
pp = np.sort(dist.cdf(x)) sns.scatterplot(x=p, y=pp, color='blue', edgecolor='blue', ax=ax, s=8) ax.margins(x=0, y=0) if line: ax.plot(np.linspace(0, 1), np.linspace(0, 1), 'r', lw=2) return ax fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2, dpi=1300) pp_plot(logeados, stats.gennorm(beta=parametros_gennormal[0], loc=parametros_gennormal[1], scale=parametros_gennormal[2]), line=True, ax=ax1) ax1.set_title('Normal generalizada', fontsize=11) pp_plot(logeados, stats.genpareto(c=parametros_pareto[0], loc=parametros_pareto[1], scale=parametros_pareto[2]), line=True, ax=ax2) ax2.set_title('Pareto generalizada', fontsize=11) pp_plot(logeados,
mean, var, skew, kurt = gennorm.stats(beta, moments='mvsk') # Display the probability density function (``pdf``): x = np.linspace(gennorm.ppf(0.01, beta), gennorm.ppf(0.99, beta), 100) ax.plot(x, gennorm.pdf(x, beta), 'r-', lw=5, alpha=0.6, label='gennorm pdf') # Alternatively, the distribution object can be called (as a function) # to fix the shape, location and scale parameters. This returns a "frozen" # RV object holding the given parameters fixed. # Freeze the distribution and display the frozen ``pdf``: rv = gennorm(beta) ax.plot(x, rv.pdf(x), 'k-', lw=2, label='frozen pdf') # Check accuracy of ``cdf`` and ``ppf``: vals = gennorm.ppf([0.001, 0.5, 0.999], beta) np.allclose([0.001, 0.5, 0.999], gennorm.cdf(vals, beta)) # True # Generate random numbers: r = gennorm.rvs(beta, size=1000) # And compare the histogram: ax.hist(r, normed=True, histtype='stepfilled', alpha=0.2)