def __init__(self):
self.hoursOpen = D.HOURS_OPEN
self.nExamRooms = D.N_EXAM_ROOMS
self.arrivalTimeDist = RVGs.Exponential(scale=D.MEAN_ARRIVAL_TIME)
self.examTimeDist = RVGs.Exponential(scale=D.MEAN_EXAM_DURATION)
self.probDepression = D.PROB_DEPRESSION
self.mentalHealthConsultDist = RVGs.Exponential(
scale=D.MEAN_MH_CONSULT)
def plot_gamma_poisson_fit(data,
fit_results,
title=None,
x_label=None,
x_range=None,
y_range=None,
fig_size=(6, 5),
bin_width=1,
filename=None):
"""
:param data: (numpy.array) observations
:param fit_results: dictionary with keys "a", "gamma_scale", "loc"
:param title: title of the figure
:param x_label: label to show on the x-axis of the histogram
:param x_range: (tuple) x range
:param y_range: (tuple) y range
(the histogram shows the probability density so the upper value of y_range should be 1).
:param fig_size: int, specify the figure size
:param bin_width: bin width
:param filename: filename to save the figure as
"""
plot_fit_discrete(data=data,
dist=RVGs.GammaPoisson(
a=fit_results['a'],
gamma_scale=fit_results['gamma_scale'],
loc=fit_results['loc']),
label='Gamma-Poisson',
bin_width=bin_width,
title=title,
x_label=x_label,
x_range=x_range,
y_range=y_range,
fig_size=fig_size,
filename=filename)
def test_fitting_beta():
print("\nTesting Beta with a=2, b=3, loc=1, scale=2:")
dist = RVGs.Beta(a=2, b=3, loc=1, scale=2)
print(' percentile interval: ', dist.get_percentile_interval(alpha=0.05))
data = np.array(get_samples(dist, np.random))
# method of moment
dict_mm_results = RVGs.Beta.fit_mm(mean=np.mean(data),
st_dev=np.std(data),
minimum=1,
maximum=3)
# maximum likelihood
dict_ml_results = RVGs.Beta.fit_ml(data=data, minimum=1, maximum=3)
print(" Fit:")
print(" MM:", dict_mm_results)
print(" ML:", dict_ml_results)
# plot the fitted distributions
Plot.plot_beta_fit(data=data,
fit_results=dict_mm_results,
title='Method of Moment')
Plot.plot_beta_fit(data=data,
fit_results=dict_ml_results,
title='Maximum Likelihood')
def test_fitting_binomial():
print("\nTesting Binomial with n=100, p=0.3, loc=1:")
dist = RVGs.Binomial(n=100, p=0.3, loc=1)
print(' percentile interval: ', dist.get_percentile_interval(alpha=0.05))
data = np.array(get_samples(dist, np.random))
# method of moment
dict_mm_results = RVGs.Binomial.fit_mm(mean=np.mean(data),
st_dev=np.std(data),
fixed_location=1)
# maximum likelihood
dict_ml_results = RVGs.Binomial.fit_ml(data=data, fixed_location=1)
print(" Fit:")
print(" MM:", dict_mm_results)
print(" ML:", dict_ml_results)
# plot the fitted distributions
Plot.plot_binomial_fit(data=data,
fit_results=dict_mm_results,
title='Method of Moment')
Plot.plot_binomial_fit(data=data,
fit_results=dict_ml_results,
title='Maximum Likelihood')
def sample_indices(self, rng):
"""
:param rng: random number generator
:return: (list) indices of sampled categories
(in the example above, [1, 0] corresponds to age group 1 and sex group 0.
"""
probs = []
if self._ifOneDim:
probs = self._objs
else:
for df in self._objs:
probs.append(df.get_sum())
empirical_dist = RVGs.Empirical(probabilities=np.array(probs) /
sum(probs))
idx = empirical_dist.sample(rng=rng)
if self._ifOneDim:
return [idx]
else:
a = [idx]
a.extend(self._objs[idx].sample_indices(rng))
return a
def test_normal(rnd, loc=0, scale=1):
#normal random variate generator
normal_dist = RVGs.Normal(loc, scale)
# obtain samples
samples = get_samples(normal_dist, rnd)
# report mean and variance
print_test_results('Normal', samples, expectation=loc, variance=scale**2)
def __init__(self, err_sigma):
""""
:param err_sigma is the standard deviation of noise term
"""
SimModel.__init__(self)
# create a normal distribution to model noise
self._err = RVGs.Normal(loc=0, scale=err_sigma)
def test_poisson(rnd, mu, loc=0):
# poisson random variate generator
poisson_dist = RVGs.Poisson(mu, loc)
# obtain samples
samples = get_samples(poisson_dist, rnd)
# report mean and variance
print_test_results('Poisson', samples, expectation=mu + loc, variance=mu)
def test_fitting_empirical():
print("\nTesting empirical with p=[0.1, 0.2, 0.7]")
dist = RVGs.Empirical(probabilities=[0.1, 0.2, 0.7])
data = np.array(get_samples(dist, np.random))
# method of moments
dict_mm_results = RVGs.Empirical.fit_mm(data=data, bin_size=1)
print(" Fit:")
print(" MM:", dict_mm_results)
def test_non_homogeneous_exponential(rnd, rates, delta_t=1):
# non homogeneous exponential random variate generator
nhexp_dist = RVGs.NonHomogeneousExponential(rates=rates, delta_t=delta_t)
# obtain samples
samples = get_samples(nhexp_dist, rnd)
# report mean and variance
print_test_results('Non-Homogeneous Exponential',
samples,
expectation=0,
variance=0)
def test_johnsonsu(rnd, a, b, loc, scale):
# johnsonSu random variate generator
johnsonsu_dist = RVGs.JohnsonSu(a, b, loc, scale)
# obtain samples
samples = get_samples(johnsonsu_dist, rnd)
# report mean and variance
mean = scipy.johnsonsu.mean(a, b, loc, scale)
var = scipy.johnsonsu.var(a, b, loc, scale)
print_test_results('JohnsonSu', samples, expectation=mean, variance=var)
def test_geometric(rnd, p, loc=0):
# geometric random variate generator
geometric_dist = RVGs.Geometric(p, loc)
# obtain samples
samples = get_samples(geometric_dist, rnd)
# report mean and variance
print_test_results('Geometric',
samples,
expectation=1 / p + loc,
variance=(1 - p) / (p**2))
def test_gamma(rnd, a, loc=0, scale=1):
# gamma random variate generator
gamma_dist = RVGs.Gamma(a=a, scale=scale, loc=loc)
# obtain samples
samples = get_samples(gamma_dist, rnd)
# report mean and variance
print_test_results('Gamma',
samples,
expectation=a * scale + loc,
variance=a * scale**2)
def test_uniform(rnd, loc=0, scale=1):
# uniform random variate generator
uniform_dist = RVGs.Uniform(scale=scale, loc=loc)
# obtain samples
samples = get_samples(uniform_dist, rnd)
# report mean and variance
print_test_results('Uniform',
samples,
expectation=(2 * loc + scale) / 2.0,
variance=scale**2 / 12.0)
def test_uniform_discrete(rnd, l, u):
# uniform discrete random variate generator
uniformdiscrete_dist = RVGs.UniformDiscrete(l, u)
# obtain samples
samples = get_samples(uniformdiscrete_dist, rnd)
# report mean and variance
print_test_results('Uniform Discrete',
samples,
expectation=(l + u) / 2.0,
variance=((u - l + 1)**2 - 1) / 12.0)
def test_lognormal(rnd, mu, sigma, loc):
#lognormal random variate generator
lognormal_dist = RVGs.LogNormal(mu=mu, sigma=sigma, loc=loc)
# obtain samples
samples = get_samples(lognormal_dist, rnd)
# report mean and variance
print_test_results('LogNormal',
samples,
expectation=np.exp(mu + 0.5 * sigma**2) + loc,
variance=(np.exp(sigma**2) - 1.0) *
np.exp(2 * mu + sigma**2))
def test_exponential(rnd, scale, loc=0):
# exponential random variate generator
exp_dist = RVGs.Exponential(scale, loc)
# obtain samples
samples = get_samples(exp_dist, rnd)
# report mean and variance
print_test_results('Exponential',
samples,
expectation=scale + loc,
variance=scale**2)
def test_binomial(rnd, n, p, loc=0):
# bimonial random variate generator
binomial_dist = RVGs.Binomial(n, p, loc)
# obtain samples
samples = get_samples(binomial_dist, rnd)
# report mean and variance
print_test_results('Binomial',
samples,
expectation=n * p + loc,
variance=n * p * (1 - p))
def test_bernoulli(rnd, p):
# bernoulli random variate generator
bernoulli_dist = RVGs.Bernoulli(p)
# obtain samples
samples = get_samples(bernoulli_dist, rnd)
# report mean and variance
print_test_results('Bernoulli',
samples,
expectation=p,
variance=p * (1 - p))
def test_gamma_poisson(rnd, a, gamma_scale, loc=0):
# gamma-poisson random variate generator
gamma_poisson_dist = RVGs.GammaPoisson(a=a,
gamma_scale=gamma_scale,
loc=loc)
# obtain samples
samples = get_samples(gamma_poisson_dist, rnd)
# report mean and variance
print_test_results('GammaPoisson',
samples,
expectation=(a * gamma_scale) + loc,
variance=a * gamma_scale + a * (gamma_scale**2))
def test_beta_binomial(rnd, n, a, b, loc=0):
# beta random variate generator
beta_binomial_dist = RVGs.BetaBinomial(n, a, b, loc)
# obtain samples
samples = get_samples(beta_binomial_dist, rnd)
# report mean and variance
print_test_results('BetaBinomial',
samples,
expectation=(a * n / (a + b)) + loc,
variance=(n * a * b * (a + b + n)) / ((a + b)**2 *
(a + b + 1)))
def test_beta(rnd, a, b, loc=0, scale=1):
# beta random variate generator
beta_dist = RVGs.Beta(a, b, loc, scale)
# obtain samples
samples = get_samples(beta_dist, rnd)
# report mean and variance
print_test_results('Beta',
samples,
expectation=(a * 1.0 / (a + b)) * scale + loc,
variance=((a * b) / ((a + b + 1) * (a + b)**2.0)) *
scale**2)
def utility_sample_stat(utility, d_cost_samples, d_effect_samples,
wtp_random_variate, n_samples, rnd):
discrete_rnd = RVG.UniformDiscrete(l=0, u=len(d_cost_samples) - 1)
samples = []
for i in range(n_samples):
j = discrete_rnd.sample(rnd)
u = utility(d_effect=d_effect_samples[j], d_cost=d_cost_samples[j])
w = wtp_random_variate.sample(rnd)
samples.append(u(w))
return Stat.SummaryStat(name='', data=samples)
def test_multinomial(rnd, n, pvals):
# multinomial random variate generator
multinomial_dist = RVGs.Multinomial(n, pvals)
# obtain samples
samples = get_samples(multinomial_dist, rnd)
pvals = np.array(pvals)
# report mean and variance
print_test_results_multivariate('Multinomial',
samples,
expectation=n * pvals,
variance=n * pvals * (1 - pvals),
axis=0)
def test_fitting_johnson_sb():
print("\nTesting Johnson Sb with a=10, b=5, loc=10, scale=100")
dist = RVGs.JohnsonSb(a=10, b=5, loc=10, scale=100)
print(' percentile interval: ', dist.get_percentile_interval(alpha=0.05))
data = np.array(get_samples(dist, np.random))
dict_ml_results = RVGs.JohnsonSb.fit_ml(data=data, fixed_location=10)
print(" Fit:")
print(" ML:", dict_ml_results)
# plot the fitted distributions
Plot.plot_johnson_sb_fit(data=data,
fit_results=dict_ml_results,
title='Maximum Likelihood')
def get_obj_value(self, x, seed_index=0):
""" returns one realization from x^2+noise """
# create a random number generator
rng = RVGs.RNG(seed=seed_index)
accum_penalty = 0 # accumulated penalty
# test the feasibility
if x[1] < 1:
accum_penalty += self._penalty * pow(x[1] - 1, 2)
x[1] = 1
return (x[0] + 1) * (x[0] + 1) + x[1] * x[1] + self._err.sample(
rng) + accum_penalty
def test_fitting_triangular():
print("\nTesting triangular with c=0.2, loc=6, scale=7")
dist = RVGs.Triangular(c=0.2, loc=6, scale=7)
print(' percentile interval: ', dist.get_percentile_interval(alpha=0.05))
data = np.array(get_samples(dist, np.random))
dict_ml_results = RVGs.Triangular.fit_ml(data=data, fixed_location=6)
print(" Fit:")
print(" ML:", dict_ml_results)
# plot the fitted distributions
Plot.plot_triangular_fit(data=data,
fit_results=dict_ml_results,
title='Maximum Likelihood')
def test_triangular(rnd, c, loc=0, scale=1):
# triangular random variate generator
triangular_dist = RVGs.Triangular(c, loc, scale)
# obtain samples
samples = get_samples(triangular_dist, rnd)
# get theoretical variance
var = scipy.triang.stats(c, loc, scale, moments='v')
var = np.asarray(var).item()
# report mean and variance
print_test_results('Triangular',
samples,
expectation=(3 * loc + scale + c * scale) / 3.0,
variance=var)
def test_weibull(rnd, a, loc=0, scale=1):
# weibull random variate generator
weibull_dist = RVGs.Weibull(a=a, scale=scale, loc=loc)
# obtain samples
samples = get_samples(weibull_dist, rnd)
# get theoretical variance
var = scipy.weibull_min.stats(a, loc, scale, moments='v')
var = np.asarray(var).item()
# report mean and variance
print_test_results('Weibull',
samples,
expectation=math.gamma(1.0 + 1 / a) * scale + loc,
variance=var)
def test_empirical(rnd, prob):
# empirical random variate generator
empirical_dist = RVGs.Empirical(prob)
# obtain samples
samples = get_samples(empirical_dist, rnd)
# report mean and variance
if type(prob) == list:
prob = np.array(prob)
outcome = np.array(range(len(prob)))
mean = sum(outcome * prob)
var = sum((outcome**2) * prob) - mean**2
print_test_results('Empirical', samples, expectation=mean, variance=var)
