def plot_pdf_fit(self, label=None):
import matplotlib.pyplot as plt
from scipy.stats import exponweib, rayleigh
from scipy import linspace, diff
plt.bar(self.pdf[1][:len(self.pdf[0])],
self.pdf[0],
width=diff(self.pdf[1]),
label=label,
alpha=0.5,
color='k')
x = linspace(0, 50, 1000)
plt.plot(x,
exponweib.pdf(x,
a=self.weibull_params[0],
c=self.weibull_params[1],
scale=self.weibull_params[3]),
'b--',
label='Exponential Weibull pdf')
plt.plot(x,
rayleigh.pdf(x, scale=self.rayleigh_params[1]),
'r--',
label='Rayleigh pdf')
plt.title('Normalized distribution of wind speeds')
plt.grid()
plt.legend()
def expectatedCapacityFactorFromWeibull(powerCurve,
meanWindspeed=5,
weibullShape=2):
"""Computes the expected capacity factor of a wind turbine based on an assumed Weibull distribution of observed wind speeds
"""
from scipy.special import gamma
from scipy.stats import exponweib
# Get windspeed distribution
lam = meanWindspeed / gamma(1 + 1 / weibullShape)
dws = 0.001
ws = np.arange(0, 40, dws)
pdf = exponweib.pdf(ws, 1, weibullShape, scale=lam)
# Estimate generation
powerCurveInterp = splrep(powerCurve.ws, powerCurve.cf)
gen = splev(ws, powerCurveInterp)
# Do some "just in case" clean-up
cutin = powerCurve.ws.min(
) # use the first defined windspeed as the cut in
cutout = powerCurve.ws.max(
) # use the last defined windspeed as the cut out
gen[gen < 0] = 0 # floor to zero
gen[ws < cutin] = 0 # Drop power to zero before cutin
gen[ws > cutout] = 0 # Drop power to zero after cutout
# Done
totalGen = (gen * pdf).sum() * dws
return totalGen
def returnDistData(cls, self):
gammaParam = gamma.fit(10**(self.data / 10))
gammaDist = gamma.pdf(self.data, *gammaParam)
rayleighParam = rayleigh.fit(self.data)
rayleighDist = rayleigh.pdf(self.data, *rayleighParam)
normParam = norm.fit(self.data)
normDist = norm.pdf(self.data, *normParam)
logNormParam = lognorm.fit(self.data)
lognormDist = lognorm.pdf(self.data, *logNormParam)
nakagamiParam = nakagami.fit(self.data)
nakagamiDist = nakagami.pdf(self.data, *nakagamiParam)
exponParam = expon.fit(self.data)
exponDist = expon.pdf(self.data, *exponParam)
exponweibParam = exponweib.fit(self.data)
weibDist = exponweib.pdf(self.data, *exponweibParam)
distDF = pd.DataFrame(np.column_stack([
gammaDist, rayleighDist, normDist, lognormDist, nakagamiDist,
exponDist, weibDist
]),
columns=[
'gammaDist', 'rayleighDist', 'normDist',
'lognormDist', 'nakagamiDist', 'exponDist',
'weibDist'
])
self.distDF = distDF
def fit_tests(features, ind=True, q=0.90, verbose=False):
"""
Input:
features: a dictionary like with the numerical results from the
QC tests. For example, the gradient test values, not the
flags, but the floats itself, like
{'gradient': ma.array([.23, .12, .08]), 'spike': ...}
ind: The features values positions to be considered in the fit.
It's usefull to eliminate out of range data, or to
restrict to a subset of the data, like in the calibration
procedure.
q: The lowest percentile to be considered. For example, .90
means that only the top 10% data (i.e. percentiles higher
than .90) are considered in the fitting.
"""
output = {}
for test in features:
samp = features[test][ind & np.isfinite(features[test])]
ind_top = samp > samp.quantile(q)
if ind_top.any():
param = exponweib.fit(samp[ind_top])
output[test] = {'param': param,
'qlimit': samp.quantile(q)}
if verbose is True:
import pylab
x = np.linspace(samp[ind_top].min(), samp[ind_top].max(), 100)
pdf_fitted = exponweib.pdf(x, *param[:-2], loc=param[-2], scale=param[-1])
pylab.plot(x, pdf_fitted, 'b-')
pylab.hist(ma.array(samp[ind_top]), 100, normed=1, alpha=.3)
pylab.title(test)
pylab.show()
return output
def score(x):
"""
DOCSTRING NEEDED
"""
c, r, h = unpack(x)
s = np.log(h / roughness) / _s
pdf = exponweib.pdf(ws, a=1, c=weibK, loc=0, scale=weibL * s)
pc = SyntheticPowerCurve(capacity=c, rotordiam=r)
cf = np.interp(ws, pc.ws, pc.cf)
expectedCapFac = (cf * pdf).sum() * dws
capex = costModel(capacity=c, hubHeight=h, rotordiam=r)
lcoe = simpleLCOE(capex, expectedCapFac * 8760 * c)
# Dissuade against too low specific-capacity values
if not minSpecificCapacity is None:
specificCapacity = 1000 * c / (np.pi * r * r / 4)
if specificCapacity < minSpecificCapacity:
lcoe += np.power(minSpecificCapacity - specificCapacity, 3)
# Dissuade against too-low hub height compared to the rotor diameter
tmp = (groundClearance + r / 2) - h
if tmp > 0: lcoe += np.power(tmp, 3)
# Done!
return lcoe
def test_with_scipy(self):
if not SP:
raise nose.SkipTest("SciPy not installed.")
parameters = {"alpha": 2, "k": 0.3, "loc": 1, "scale": 3}
r = rexponweib(size=10, **parameters)
a = exponweib.pdf(r, 2, 0.3, 1, 3)
b = exponweib_like(r, **parameters)
assert_almost_equal(log(a).sum(), b, 5)
def Likelihood(self, data, hypo): age, alive = data k, lam = hypo if alive: prob = 1-exponweib.cdf(age, k, lam) else: prob = exponweib.pdf(age, k, lam) return prob
def Likelihood(self, data, hypo):
age, alive = data
k, lam = hypo
if alive:
prob = 1 - exponweib.cdf(age, k, lam)
else:
prob = exponweib.pdf(age, k, lam)
return prob
def test_with_scipy(self):
if not SP:
raise nose.SkipTest("SciPy not installed.")
parameters = {'alpha': 2, 'k': .3, 'loc': 1, 'scale': 3}
r = rexponweib(size=10, **parameters)
a = exponweib.pdf(r, 2, .3, 1, 3)
b = exponweib_like(r, **parameters)
assert_almost_equal(log(a).sum(), b, 5)
def test_with_scipy(self):
if not SP:
raise nose.SkipTest("SciPy not installed.")
parameters = {'alpha': 2, 'k': .3, 'loc': 1, 'scale': 3}
r = rexponweib(size=10, **parameters)
a = exponweib.pdf(r, 2, .3, 1, 3)
b = exponweib_like(r, **parameters)
assert_almost_equal(log(a).sum(), b, 5)
def Likelihood(self, data, hypo):
"""Determines how well a given k and lam predict the life/death of a character """
age, alive = data
k, lam = hypo
if alive:
prob = 1 - exponweib.cdf(age, k, lam)
else:
prob = exponweib.pdf(age, k, lam)
return prob
def Likelihood(self, data, hypo): """Determines how well a given k and lam predict the life/death of a character """ age, alive = data k, lam = hypo if alive: prob = 1-exponweib.cdf(age, k, lam) else: prob = exponweib.pdf(age, k, lam) return prob
def test_fit_weibull(y):
"""The PDF really doesn't look like the data. Might the parameters be wrong?
"""
a, b, loc, scale = exponweib.fit(y)
x = linspace(0, y.max())
pdf_fitted = exponweib.pdf(x, a, b, loc, scale)
title("Weibull distribution: (a=%.2f,b=%.2f) loc = %.2f, scale = %.2f" %
(a, b, loc, scale))
plot(x, pdf_fitted, 'r-')
hist(y, normed=1, alpha=.3, bins=int(y.max()))
show()
return a, b, loc, scale
def fit_weib2():
# 生成韦伯分布数据
sample = exponweib.rvs(a=10, c=1, scale=3, loc=0, size=1000)
x = np.linspace(0, np.max(sample), 100)
#拟合
a, c, loc, scale = exponweib.fit(sample, floc=0, fa=1)
print(a, c, loc, scale)
y = exponweib.pdf(x, a, c, loc, scale)
for x1, y1 in zip(x, y):
print(x1, y1)
plt.plot(x, y)
plt.show()
def expected_capacity_factor_from_weibull(self,
mean_wind_speed=5,
weibull_shape=2):
"""
Computes the expected average capacity factor of a wind turbine based on a Weibull distribution of wind speeds.
Parameters
----------
mean_wind_speed : int, optional
mean wind speed at the location in m/s, by default 5
weibull_shape : int, optional
Weibull shape parameter, by default 2
Returns
-------
numeric
Average capacity factor
See also
-------
PowerCurve.expected_capacity_factor_from_distribution
"""
from scipy.special import gamma
from scipy.stats import exponweib
# Get windspeed distribution
lam = mean_wind_speed / gamma(1 + 1 / weibull_shape)
dws = 0.001
ws = np.arange(0, 40, dws)
pdf = exponweib.pdf(ws, 1, weibull_shape, scale=lam)
# Estimate generation
power_curveInterp = splrep(self.wind_speed, self.capacity_factor)
gen = splev(ws, power_curveInterp)
# Do some "just in case" clean-up
cutin = self.wind_speed.min(
) # use the first defined windspeed as the cut in
cutout = self.wind_speed.max(
) # use the last defined windspeed as the cut out
gen[gen < 0] = 0 # floor to zero
gen[ws < cutin] = 0 # Drop power to zero before cutin
gen[ws > cutout] = 0 # Drop power to zero after cutout
# Done
meanCapFac = (gen * pdf).sum() * dws
return meanCapFac
def plot_pdf_fit(self, label=None):
import matplotlib.pyplot as plt
from scipy.stats import exponweib, rayleigh
from scipy import linspace, diff
plt.bar(self.pdf[1][:len(self.pdf[0])], self.pdf[0], width=diff(self.pdf[1]), label=label, alpha=0.5, color='k')
x = linspace(0, 50, 1000)
plt.plot(x, exponweib.pdf(x, a=self.weibull_params[0], c=self.weibull_params[1], scale=self.weibull_params[3]),
'b--', label='Exponential Weibull pdf')
plt.plot(x, rayleigh.pdf(x, scale=self.rayleigh_params[1]), 'r--', label='Rayleigh pdf')
plt.title('Normalized distribution of wind speeds')
plt.grid()
plt.legend()
def example_4():
a, c = 3, 1
data = exponweib.rvs(a, c, size=1000)
pf = lambda ah, ch=c, d=data: -np.sum(np.log(exponweib.pdf(data, ah, ch)))
x0 = 2
sols = {}
methods = ["nelder-mead", "powell", "Anneal", "BFGS", "TNC", "L-BFGS-B", "SLSQP"]
for method in sorted(methods):
th = {'success': False}
while not th['success']:
th = minimizer(x0, pf, method)
print '{0} ({1}): {2}'.format(method, x0, th['message'])
x0 = np.random.uniform(0, 10)
sols[method] = th['x']
for i, (method, sol) in enumerate(sols.iteritems()):
print '{0}: {1}'.format(method, sol)
def example_1():
a, c = 3, 1
xs = np.linspace(exponweib.ppf(0.01, a, c), exponweib.ppf(0.99, a, c), 100)
l = round(max(xs) - min(xs))
pf = lambda x: exponweib.pdf(x, a, c)
e = 1 # step size of random-walk
qrf = lambda x: norm.rvs(x, e)
x0 = 2
xhs0 = metropolis_hastings(x0, 100000, pf, qrf, None, None, False)
xhs = prune(xhs0, l, e)
plt.plot(xs, pf(xs), color='b', label='actual posterior')
plt.hist(xhs, 100, color='c', normed=True, label='pruned m-h samples')
plt.xlabel('x')
plt.ylabel('normalized count')
plt.legend()
# plt.savefig('../img/example-1.png')
plt.show()
def fit_distribution(data, fit_type, x_min, x_max, n_points=1000):
# Initialization of the variables
param, x, cdf, pdf = [-1, -1, -1, -1]
if fit_type == 'exponweib':
x = np.linspace(x_min, x_max, n_points)
# Fit data to the theoretical distribution
param = exponweib.fit(data, 1, 1, scale=02, loc=0)
# param = exponweib.fit(data, fa=1, floc=0)
# param = exponweib.fit(data)
cdf = exponweib.cdf(x, param[0], param[1], param[2], param[3])
pdf = exponweib.pdf(x, param[0], param[1], param[2], param[3])
elif fit_type == 'lognorm':
x = np.linspace(x_min, x_max, n_points)
# Fit data to the theoretical distribution
param = lognorm.fit(data, loc=0)
cdf = lognorm.cdf(x, param[0], param[1], param[2])
pdf = lognorm.pdf(x, param[0], param[1], param[2])
elif fit_type == 'norm':
x = np.linspace(x_min, x_max, n_points)
# Fit data to the theoretical distribution
param = norm.fit(data, loc=0)
cdf = norm.cdf(x, param[0], param[1])
pdf = norm.pdf(x, param[0], param[1])
elif fit_type == 'weibull_min':
x = np.linspace(x_min, x_max, n_points)
# Fit data to the theoretical distribution
param = weibull_min.fit(data, floc=0)
cdf = weibull_min.cdf(x, param[0], param[1], param[2])
pdf = weibull_min.pdf(x, param[0], param[1], param[2])
return param, x, cdf, pdf
def example_2():
a, c = 3, 1
data = exponweib.rvs(a, c, size=1000)
l = round(max(data) - min(data))
pf = lambda ah, ch=c, d=data: np.sum(np.log(exponweib.pdf(data, ah, ch)))
e = 1 # step size of random-walk
qrf = lambda x, e=e: norm.rvs(x, e)
x0 = 2
ahs0 = metropolis_hastings(x0, 100000, pf, qrf)
# ahs = ahs0
ahs = prune(ahs0, l, e)
print 'Generated {0} samples after pruning from {1}.'.format(len(ahs), len(ahs0))
print min(ahs), max(ahs)
plt.axvline(a, label='theta', color='b', linestyle='--')
plt.hist(ahs, 100, normed=True, label='pruned m-h samples')
plt.legend()
# plt.savefig('../img/example-2.png')
plt.show()
def fit_tests(features, q=0.90, verbose=False):
"""
Input:
features: a dictionary like with the numerical results from the
QC tests. For example, the gradient test values, not the
flags, but the floats itself, like
{'gradient': ma.array([.23, .12, .08]), 'spike': ...}
It also works with a pandas.DataFrame()
q: The lowest percentile to be considered. For example, .90
means that only the top 10% data (i.e. percentiles higher
than .90) are considered in the fitting.
"""
assert (q >= 0) & (q < 1), "q must be in [0, 1)"
output = {}
for f in features:
# Sample only valid values
samp = ma.compressed(features[f][np.isfinite(features[f])])
# Identify the percentile q
qlimit = np.percentile(samp, 1e2 * q)
# Restricts to the top q values
samp = samp[samp > qlimit]
if samp.any():
param = exponweib.fit(samp)
output[f] = {'param': param, 'qlimit': qlimit}
if verbose is True:
import pylab
x = np.linspace(samp.min(), samp.max(), 100)
pdf_fitted = exponweib.pdf(x,
*param[:-2],
loc=param[-2],
scale=param[-1])
pylab.plot(x, pdf_fitted, 'b-')
pylab.hist(ma.array(samp), 100, normed=1, alpha=.3)
pylab.title(f)
pylab.show()
return output
def example_3():
a, c = 3, 1
data = exponweib.rvs(a, c, size=1000)
l = round(max(data) - min(data))
pf = lambda ah, ch=c, d=data: np.sum(np.log(exponweib.pdf(data, ah, ch)))
d = 1.0
Tf = lambda i: d/np.log(i+2) # cooling function
e = 1 # step size of random-walk
qrf = lambda x, e=e: norm.rvs(x, e)
x0 = 2
ahs0 = simulated_annealing(x0, 100000, pf, qrf, Tf)
print 'Generated {0} samples. MAP estimate is {1}'.format(len(ahs0), ahs0[-1])
plt.hist(ahs0, 100, normed=True, label='samples')
plt.axvline(a, label='theta', color='b', linestyle='--')
plt.axvline(ahs0[-1], label='theta-hat', color='c', linestyle='--')
plt.xlim([2.8, 3.4])
plt.legend()
# plt.savefig('../img/example-3.png')
plt.show()
def fit_tests(features, ind=True, q=0.90, verbose=False):
"""
Input:
features: a dictionary like with the numerical results from the
QC tests. For example, the gradient test values, not the
flags, but the floats itself, like
{'gradient': ma.array([.23, .12, .08]), 'spike': ...}
ind: The features values positions to be considered in the fit.
It's usefull to eliminate out of range data, or to
restrict to a subset of the data, like in the calibration
procedure.
q: The lowest percentile to be considered. For example, .90
means that only the top 10% data (i.e. percentiles higher
than .90) are considered in the fitting.
"""
output = {}
for test in features:
samp = features[test][ind & np.isfinite(features[test])]
ind_top = samp > samp.quantile(q)
if ind_top.any():
param = exponweib.fit(samp[ind_top])
output[test] = {'param': param, 'qlimit': samp.quantile(q)}
if verbose is True:
import pylab
x = np.linspace(samp[ind_top].min(), samp[ind_top].max(), 100)
pdf_fitted = exponweib.pdf(x,
*param[:-2],
loc=param[-2],
scale=param[-1])
pylab.plot(x, pdf_fitted, 'b-')
pylab.hist(ma.array(samp[ind_top]), 100, normed=1, alpha=.3)
pylab.title(test)
pylab.show()
return output
from scipy.stats import exponweib print(exponweib.pdf(2,1,3,0,4))
def optfun(theta):
return -np.sum(np.log(exponweib.pdf(x, 1, theta[0], scale = theta[1], loc = 0)))
def fexpweib(x,a,c,s,l): return exponweib.pdf(x,a,c,loc=l,scale=s);
#for a in np.arange(1.0,1, 1.0): a = 1.0; #cvals = np.linspace(1.0,3.14,10) cvals = [1.0,1.5,1.8,2.1,3.34] scvals = np.linspace(50.0,50.0,1) cmapp = np.linspace(0.0,1.0,len(scvals)); colors = [ cm.jet(x) for x in cmapp ] for i in range(len(scvals)): #np.arange(1.0,5.1, 0.5): sc = scvals[i] color = colors[i] for j in range(len(cvals)): c = cvals[j] x = np.linspace(0, exponweib.ppf(0.9999,a,c,scale=sc),1000) plt.plot(x,exponweib.pdf(x,a,c,scale=sc),color=color,alpha=0.5,label=str(c)) plt.ylim((0.0,0.028)) plt.xlim((0.0,200.0)) plt.legend(); plt.show() exit() def fexpweib(x,a,c,s,l): return exponweib.pdf(x,a,c,loc=l,scale=s); bins = 1000;
def fitDist(self):
n = len(self.data)
# gamma distribution
gammaParam = gamma.fit(self.data)
gammaNumPar = len(gammaParam)
gammaSum = -1 * np.sum(np.log(gamma.pdf(self.data, *gammaParam)))
aicGamma = 2 * gammaNumPar + 2 * gammaSum + (2 * gammaNumPar *
(gammaNumPar + 1) /
(n - gammaNumPar - 1))
# rayleigh distribution
rayleighParam = rayleigh.fit(self.data)
rayleighNumPar = len(rayleighParam)
rayleighSum = -1 * np.sum(
np.log(rayleigh.pdf(self.data, *rayleighParam)))
aicRayleigh = 2 * rayleighNumPar + 2 * rayleighSum + (
2 * rayleighNumPar * (rayleighNumPar + 1) /
(n - rayleighNumPar - 1))
# normal distribution
normParam = norm.fit(self.data)
normNumPar = len(normParam)
normSum = -1 * np.sum(np.log(norm.pdf(self.data, *normParam)))
aicNorm = 2 * normNumPar + 2 * normSum + (2 * normNumPar *
(normNumPar + 1) /
(n - normNumPar - 1))
# LogNormal distribution
logNormParam = lognorm.fit(self.data)
logNormNumPar = len(logNormParam)
logNormSum = -1 * np.sum(np.log(lognorm.pdf(self.data, *logNormParam)))
aicLogNorm = 2 * logNormNumPar + 2 * logNormSum + (
2 * logNormNumPar * (logNormNumPar + 1) / (n - logNormNumPar - 1))
# Nakagami distribution
nakagamiParam = nakagami.fit(self.data)
nakagamiNumPar = len(nakagamiParam)
nakagamiSum = -1 * np.sum(
np.log(nakagami.pdf(self.data, *nakagamiParam)))
aicNakagami = 2 * nakagamiNumPar + 2 * nakagamiSum + (
2 * nakagamiNumPar * (nakagamiNumPar + 1) /
(n - nakagamiNumPar - 1))
# exponential distribution
exponParam = expon.fit(self.data)
exponNumPar = len(exponParam)
exponSum = -1 * np.sum(np.log(expon.pdf(self.data, *exponParam)))
aicExpon = 2 * exponNumPar + 2 * exponSum + (2 * exponNumPar *
(exponNumPar + 1) /
(n - exponNumPar - 1))
# weibul distribution
exponweibParam = exponweib.fit(self.data)
exponweibNumPar = len(exponweibParam)
exponweibSum = -1 * np.sum(
np.log(exponweib.pdf(self.data, *exponweibParam)))
aicExpWeib = 2 * exponweibNumPar + 2 * exponweibSum + (
2 * exponweibNumPar * (exponweibNumPar + 1) /
(n - exponweibNumPar - 1))
return (aicGamma, aicRayleigh, aicNorm, aicLogNorm, aicNakagami,
aicExpon, aicExpWeib)
# start tensorboard
# tb = program.TensorBoard()
# tb.configure(argv=[None, '--logdir', 'checkpoints'])
# url = tb.launch()
# webbrowser.open(url)
# plot empirical distributions of MNIST and Fashion-MNIST
plot_mnist_dist()
plot_alt_dist()
# plot exemplary marginal gaussianization
# ToDo: plot_marginal_gauss causes error in gaussian_mixture_generate
if not exists(config('PATHS')['marginal_gauss']):
x1 = np.arange(0, 3, .01)
x2 = np.arange(-3, 3, .01)
pdf = exponweib.pdf(
x1, 2, 2) + randn(len(x1)) * norm.pdf(x1, loc=1, scale=.5) / 20
pdf = (pdf - min(pdf))
pdf /= np.sum(np.abs(pdf))
emp = empiric(values=(x1, pdf), reconstruct=True)
plot_marginal_gauss((x1, x2), (emp, norm), 1.5,
config('PATHS')['marginal_gauss'])
# prepare data
file = config('DATA')['normal_samples']
if not exists(file):
seed(randint(10**9))
prepare_z(file, samples=60000, dim=10)
file = config('DATA')['gaussian_mixture']
if not exists(file):
seed(randint(10**9))
# ToDo: numpy.linalg.LinAlgError: SVD did not converge
def fit_weibull_distribution_sp(data, init_a=1, init_c=1, scale=1, loc=0):
vals = exponweib.fit(data, init_a, init_c, scale=scale, loc=loc)
return vals, data, exponweib.pdf(data, *vals)
def plot_fall_distributions(fallScores):
plt.rcParams.update({'font.size': 26})
plt.rcParams['text.usetex'] = True
plt.rcParams['text.latex.preamble'] = [r'\usepackage{amsmath}']
fig, axs = plt.subplots(5, 1)
fig.set_size_inches(10, 20)
lines = []
bins = [[], [], [], [], []]
y = [[], [], [], [], []]
y2 = [[], [], [], [], []]
fallScores[4] = [fallScores[4][i] / 0.8 for i in range(len(fallScores[4]))]
labels = [
r'$\mathrm{Deterministic}$', r'$\mathrm{Probabilistic-CVaR~Cost}$',
r'$\mathrm{Probabilistic-Expected+CVaR~Cost}$',
r'$\mathrm{Probabilistic-Expected~Cost}$',
r'$\mathrm{No~Intervention}$'
]
for i in range(5):
# (mu, sigma) = rayleigh.fit(fallScores[i])
prameters = exponweib.fit(fallScores[i], floc=0)
# print(mu,sigma)
n, bins[i], patches = axs[i].hist(fallScores[i],
density=True,
stacked=True,
color="royalblue",
bins=40,
alpha=1)
# y[i] = rayleigh.pdf(bins[i], mu, sigma)
y2[i] = exponweib.pdf(bins[i], *prameters)
# axs[i].plot(bins[i], y[i], "red", linewidth=3)
axs[i].plot(bins[i], y2[i], "black", linewidth=3)
axs[i].grid(True)
axs[i].set_xlim(0, 17)
axs[i].set_ylim(0, 1)
axs[i].set_xticklabels([])
axs[i].set_yticklabels(
[r'$\mathrm{0.0}$', r'$\mathrm{0.5}$', r'$\mathrm{1.0}$'],
fontsize=20)
props = dict(boxstyle='round', facecolor='white', alpha=1)
axs[i].text(0.7,
0.9,
labels[i],
transform=axs[i].transAxes,
fontsize=14,
verticalalignment='top',
bbox=props,
ha='center')
axs[4].set_xticklabels([
r'$\mathrm{0}$', r'$\mathrm{2.5}$', r'$\mathrm{5.0}$',
r'$\mathrm{7.5}$', r'$\mathrm{10.0}$', r'$\mathrm{12.5}$',
r'$\mathrm{15}$'
],
fontsize=20)
axs[4].set_xlabel(r'$\mathrm{Fall~Score}$', fontsize=20)
axs[2].set_ylabel(r'$\mathrm{Density}$', fontsize=20)
plt.show()
fig5, ax6 = plt.subplots()
fig5.set_size_inches(15, 10)
labels = [
r'$\mathrm{Deterministic}$', r'$\mathrm{Probabilistic-CVaR~Cost}$',
r'$\mathrm{Probabilistic-Expected+CVaR~Cost}$',
r'$\mathrm{Probabilistic-Expected~Cost}$',
r'$\mathrm{No~Intervention}$'
]
colors = ['k-.', 'b--', 'r', 'b:', "k"]
for i in range(5):
lines.append(
ax6.plot(bins[i], y2[i], colors[i], linewidth=3, label=labels[i]))
# Add labels
ax6.set_xticklabels([
r'$\mathrm{}$', r'$\mathrm{2}$', r'$\mathrm{4}$', r'$\mathrm{6}$',
r'$\mathrm{8}$', r'$\mathrm{10}$', r'$\mathrm{12}$', r'$\mathrm{14}$',
r'$\mathrm{16}$'
],
fontsize=20)
ax6.set_yticklabels([
r'$\mathrm{0.00}$', r'$\mathrm{0.05}$', r'$\mathrm{0.10}$',
r'$\mathrm{0.15}$', r'$\mathrm{0.20}$', r'$\mathrm{0.25}$',
r'$\mathrm{0.30}$'
],
fontsize=20)
ax6.set_xlabel(r'$\mathrm{Fall~Score}$', fontsize=20)
ax6.set_ylabel(r'$\mathrm{Density}$', fontsize=20)
ax6.legend(fontsize=20)
ax6.grid(True)
plt.show()
def distribution(data, column, norm=True, plotWeibull=False, upperLimit=1.0, title=''):
x = np.linspace(data[column].min(), data[column].max(), 1000)
if plotWeibull:
plt.plot(x, exponweib.pdf(x, *exponweib.fit(data[column], 1, 1)))
plt.title(title)
return plt.hist(data[column], bins=np.linspace(0, upperLimit), normed=norm, alpha=0.5);
def downtime_accepted_models(D=list(), alpha=.05):
params = list()
params.append(uniform.fit(D))
params.append(expon.fit(D))
params.append(rayleigh.fit(D))
params.append(weibull_min.fit(D))
params.append(gamma.fit(D))
params.append(gengamma.fit(D))
params.append(invgamma.fit(D))
params.append(gompertz.fit(D))
params.append(lognorm.fit(D))
params.append(exponweib.fit(D))
llf_value = list()
llf_value.append(log(product(uniform.pdf(D, *params[0]))))
llf_value.append(log(product(expon.pdf(D, *params[1]))))
llf_value.append(log(product(rayleigh.pdf(D, *params[2]))))
llf_value.append(log(product(weibull_min.pdf(D, *params[3]))))
llf_value.append(log(product(gamma.pdf(D, *params[4]))))
llf_value.append(log(product(gengamma.pdf(D, *params[5]))))
llf_value.append(log(product(invgamma.pdf(D, *params[6]))))
llf_value.append(log(product(gompertz.pdf(D, *params[7]))))
llf_value.append(log(product(lognorm.pdf(D, *params[8]))))
llf_value.append(log(product(exponweib.pdf(D, *params[9]))))
AIC = list()
AIC.append(2 * len(params[0]) - 2 * llf_value[0])
AIC.append(2 * len(params[1]) - 2 * llf_value[1])
AIC.append(2 * len(params[2]) - 2 * llf_value[2])
AIC.append(2 * len(params[3]) - 2 * llf_value[3])
AIC.append(2 * len(params[4]) - 2 * llf_value[4])
AIC.append(2 * len(params[5]) - 2 * llf_value[5])
AIC.append(2 * len(params[6]) - 2 * llf_value[6])
AIC.append(2 * len(params[7]) - 2 * llf_value[7])
AIC.append(2 * len(params[8]) - 2 * llf_value[8])
AIC.append(2 * len(params[9]) - 2 * llf_value[9])
model = list()
model.append(
["uniform", params[0],
kstest(D, "uniform", params[0])[1], AIC[0]])
model.append(
["expon", params[1],
kstest(D, "expon", params[1])[1], AIC[1]])
model.append(
["rayleigh", params[2],
kstest(D, "rayleigh", params[2])[1], AIC[2]])
model.append([
"weibull_min", params[3],
kstest(D, "weibull_min", params[3])[1], AIC[3]
])
model.append(
["gamma", params[4],
kstest(D, "gamma", params[4])[1], AIC[4]])
model.append(
["gengamma", params[5],
kstest(D, "gengamma", params[5])[1], AIC[5]])
model.append(
["invgamma", params[6],
kstest(D, "invgamma", params[6])[1], AIC[6]])
model.append(
["gompertz", params[7],
kstest(D, "gompertz", params[7])[1], AIC[7]])
model.append(
["lognorm", params[8],
kstest(D, "lognorm", params[8])[1], AIC[8]])
model.append(
["exponweib", params[9],
kstest(D, "exponweib", params[9])[1], AIC[9]])
accepted_models = [i for i in model if i[2] > alpha]
if accepted_models:
aic_values = [i[3] for i in accepted_models]
final_model = min(range(len(aic_values)), key=aic_values.__getitem__)
return accepted_models, accepted_models[final_model]
elif not accepted_models:
aic_values = [i[3] for i in model]
final_model = min(range(len(aic_values)), key=aic_values.__getitem__)
return model, model[final_model]
from scipy.stats import exponweib print(exponweib.pdf(2, 1, 3, 0, 4))
import scipy.stats as stat
import numpy as np
from matplotlib import pyplot as plt
"""x = np.linspace(-1, 3000, 5000)
#y = stat.norm.pdf(x)
y = stat.exponweib.pdf(x, 1.74, 500)
plt.plot(x, y, linewidth=2)
#plt.xlim(-3, 3)
#plt.ylim(-0.2, 0.7)
plt.show()
"""
from scipy.stats import exponweib
fig, ax = plt.subplots(1, 1)
a, c = 1, 1.35
mean, var, skew, kurt = exponweib.stats(a, c, moments='mvsk')
x = np.linspace(exponweib.ppf(0.01, a, c), exponweib.ppf(0.99, a, c), 100)
ax.plot(x,
exponweib.pdf(x, a, c),
'r-',
lw=5,
alpha=0.6,
label='exponweib pdf')
plt.show()
