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)