def calculate_posteriors(installs_A, installs_B, views_A, views_B):
# Prior Parameters
alpha = .5
beta = 100
# Update Equations
alpha_post_A, beta_post_A = installs_A + alpha, beta + views_A - installs_A
alpha_post_B, beta_post_B = installs_B + alpha, beta + views_B - installs_B
# Draw samples from posteriors
posterior_A = beta_dist(a=alpha_post_A, b=beta_post_A)
posterior_B = beta_dist(a=alpha_post_B, b=beta_post_B)
return posterior_A, posterior_B
def calculate_posteriors(installs_A, installs_B, views_A, views_B):
# Prior Parameters
alpha = .5
beta = 100
# Update Equations
alpha_post_A, beta_post_A = installs_A + alpha, beta + views_A - installs_A
alpha_post_B, beta_post_B = installs_B + alpha, beta + views_B - installs_B
# Draw samples from posteriors
posterior_A = beta_dist(a=alpha_post_A, b=beta_post_A)
posterior_B = beta_dist(a=alpha_post_B, b=beta_post_B)
return posterior_A, posterior_B
def values(self):
quantiles = []
for i in range(self.k):
a, b = self.compute_ab(i)
quantiles.append(
beta_dist(a, b).ppf(1 - 1 / (self.t * np.log(self.n)**self.c)))
return quantiles
def __init__(self, k, alpha=1, beta=1, max_steps=None):
self.k = k
self.alpha = alpha
self.beta = beta
self.max_steps = max_steps
self.dist = beta_dist(self.alpha, self.beta)
def beta_pdf(alpha, beta):
""" Produce curve of beta distribution.
:param alpha: Alpha parameter of beta distribution
:param beta: Beta parameter of beta distribution
:return: curve of beta distribution
"""
x = np.linspace(0, 1, 1000)
return x, beta_dist(1 + alpha, 1 + beta).pdf(x)
def _epsilon_dist(self):
"""
"""
mu = self.param_dict['elliptical_shape_mu_1_' + self.gal_type]
sigma = self.param_dict['elliptical_shape_sigma_1_' + self.gal_type]
alpha, beta = _beta_params(mu, sigma**2)
d = beta_dist(alpha, beta)
return d
def plot(self, x, n):
""" plots the prior pdf density over the data histogram"""
# add various plotting args
x_ax = np.linspace(0, 1, 1000)
rv = beta_dist(self.alpha, self.beta)
p = x / n
plt.hist(p, density=True)
plt.plot(x_ax, rv.pdf(x_ax))
plt.title(f'Beta({self.alpha.round(2)},{self.beta.round(2)})')
plt.show()
def median(self):
""" Calculates the median
Returns
-------
Array:
Array of median values.
"""
median = (beta_dist(self.alpha, self.beta).median() *
self.range) + self.a
return median
def _gamma_prime_dist(self):
"""
gamma_prime = 1 - C/B
"""
mu = self.param_dict['elliptical_shape_mu_2_' + self.gal_type]
sigma = self.param_dict['elliptical_shape_sigma_2_' + self.gal_type]
alpha, beta = _beta_params(mu, sigma**2)
d = beta_dist(alpha, beta)
return d
def sample_init_Z_bernoulli(alpha, beta, n_samples=10):
pbeta = beta_dist(a=alpha, b=beta)
pi = pbeta.rvs(size=n_samples)
elements = np.zeros(n_samples)
for i, p in enumerate(pi):
elements[i] = bernoulli.rvs(p)
mean = elements.mean()
# unbiased variance
var = elements.var(ddof=1)
return mean, var
def rvs(self, size=1, random_state=None):
""" Returns a randompy-sampled value from the PERT
Parameters
----------
size: int (default 1)
Indicates how many random values should be returned
random_state: int (default none)
Seed value for random sample RNG.
Returns
-------
Array:
Randomly sampled values from the PERT dristribution.
"""
rvs_vals = (beta_dist(self.alpha, self.beta).rvs(
size=size, random_state=random_state) * self.range) + self.a
return rvs_vals
def main():
fig = plt.figure()
x = np.linspace(0, 1, 100)
sizes = [1, 2, 20, 50]
fig_row, fig_col = 2, 4
# Mean of i.i.d uniform
for i, n in enumerate(sizes):
ax = fig.add_subplot(fig_row, fig_col, i + 1)
data, gaussian = central_limit(uniform_dist.rvs, n, 1000)
ax.hist(data, bins=20, normed=True, alpha=0.7)
plt.plot(x, gaussian.pdf(x), 'r')
plt.title('n={0}'.format(n))
# Mean of i.i.d beta(1, 2)
for i, n in enumerate(sizes):
ax = fig.add_subplot(fig_row, fig_col, i + fig_col + 1)
data, gaussian = central_limit(beta_dist(1, 2).rvs, n, 1000)
ax.hist(data, bins=20, normed=True, alpha=0.7)
plt.plot(x, gaussian.pdf(x), 'r')
plt.title('n={0}'.format(n))
plt.show()
beta_examples = [(0, 0), (2, 0), (2, 5), (18, 9), (32, 50), (130, 80)]
# colors for the plots
beta_colors = ['blue', 'orange', 'green', 'red', 'purple', 'brown']
# opening figure
fig, ax = plt.subplots(figsize=(14, 6), dpi=150, nrows=2, ncols=3)
# loop for each
for i, example in enumerate(beta_examples):
# points to sample for drawing the curve
X = np.linspace(0, 1, 1000)
# generating the curve
dist = beta_dist(1 + example[0], 1 + example[1])
curve = dist.pdf(X)
# plotly data
ax[int(i / 3)][(i % 3)].fill_between(X,
0,
curve,
color=beta_colors[i],
alpha=0.7)
ax[int(i / 3)][(i % 3)].set_title('Sucesses: {} | Failures: {}'.format(
example[0], example[1]),
fontsize=14)
# some adjustments
ax[0][0].set(ylim=[0, 2])
plt.tight_layout()
def alpha(m_0, mod_m):
return ((1 - m_0) / (m_0 * mod_m ** 2) - 1) * m_0
def beta(m_0, mod_m):
return ((1 - m_0) / (m_0 * mod_m ** 2) - 1) * (1 - m_0)
if __name__ == "__main__":
# Number of measurements of FPOL
n = 10
# True mean intrinsic FPOL
m_0_true = 0.2
# True modulation index
mod_m_true = 0.4
print("True mean FPOL: ", m_0_true)
print("True modulation index: ", mod_m_true)
# True variable FPOL values
ms_i_true = beta_dist(alpha(m_0_true, mod_m_true), beta(m_0_true, mod_m_true)).rvs(n)
# Some errors
sigmas = 0.03*np.ones(n)
# Observed variable FPOL values
ms_obs = rice_dist(ms_i_true / sigmas, scale=sigmas).rvs(n)
print("Observed FPOL: ", ms_obs)
print("Errors of FPOL: ", sigmas)
res = fit(ms_obs, sigmas)
print("Estimated mean FPOL: ", res[0])
print("Estimated modulation index: ", res[1])
def _reset_distribution(self):
self._distribution: rv_continuous = beta_dist(a=self.alpha,
b=self.beta,
loc=self._a,
scale=self._c - self._a)
def _reset_distribution(self):
self._distribution: rv_continuous = beta_dist(self._alpha, self._beta)
elif opts.log_eff_prior:
# logarithmic uniform prior
lower_bound, upper_bound = opts.log_eff_bounds.split(',')
grb_efficiency_axis = linspace(float(lower_bound), float(upper_bound),
1000)
Norm = log(float(upper_bound) / float(lower_bound))
grb_efficiency_prior = Norm / grb_efficiency_axis
outputname = opts.outputname + "_logEffPrior-%s-%s" % (lower_bound,
upper_bound)
elif opts.berno_eff_prior:
# bernoulli trial parameter
prior_dist = beta_dist(0.5, 0.5)
grb_efficiency_axis = linspace(0.01, 0.99, 1000)
grb_efficiency_prior = prior_dist.pdf(grb_efficiency_axis)
outputname = opts.outputname + "_bernoEffPrior"
elif opts.beta_eff_prior:
# beta distribution prior
beta_vals = opts.beta_vals.split(',')
prior_dist = beta_dist(float(beta_vals[0]), float(beta_vals[1]))
grb_efficiency_axis = linspace(0.01, 0.99, 1000)
grb_efficiency_prior = prior_dist.pdf(grb_efficiency_axis)
outputname = opts.outputname + "_betaEffPrior-%s-%s" % (beta_vals[0],
beta_vals[1])
outputname=opts.outputname+"_flatEffPrior-%s-%s"%(lower_bound,upper_bound)
elif opts.log_eff_prior:
# logarithmic uniform prior
lower_bound,upper_bound=opts.log_eff_bounds.split(',')
grb_efficiency_axis=linspace(float(lower_bound),float(upper_bound),1000)
Norm=log(float(upper_bound)/float(lower_bound))
grb_efficiency_prior = Norm / grb_efficiency_axis
outputname=opts.outputname+"_logEffPrior-%s-%s"%(lower_bound,upper_bound)
elif opts.berno_eff_prior:
# bernoulli trial parameter
prior_dist=beta_dist(0.5,0.5)
grb_efficiency_axis=linspace(0.01,0.99,1000)
grb_efficiency_prior=prior_dist.pdf(grb_efficiency_axis)
outputname=opts.outputname+"_bernoEffPrior"
elif opts.beta_eff_prior:
# beta distribution prior
beta_vals=opts.beta_vals.split(',')
prior_dist=beta_dist(float(beta_vals[0]),float(beta_vals[1]))
grb_efficiency_axis=linspace(0.01,0.99,1000)
grb_efficiency_prior=prior_dist.pdf(grb_efficiency_axis)
outputname=opts.outputname+"_betaEffPrior-%s-%s"%(beta_vals[0],beta_vals[1])
def values(self):
samples = []
for i in range(self.k):
a, b = self.compute_ab(i)
samples.append(beta_dist(a, b).rvs())
return samples
def get_beta_pdf(alpha, beta):
X = np.linspace(0, 1, 1000)
return X, beta_dist(1 + alpha, 1 + beta).pdf(X)