def modified_experiment(grid_params, elfi_params, rl_params, bolfi_params, obs_data, test_data, plot_data, types, replicates, region_size, ground_truth, n_cores, path_max_len, obs_set_size, seed, pdf, figsize): elfi.new_model() model = get_model("approx", grid_params, p.get_elfi_params(), rl_params, obs_data, path_max_len, obs_set_size) inference_task = BolfiFactory(model, bolfi_params).get() bounds = elfi_params.get_bounds() ret = dict() ret["n_cores"] = n_cores ret["MD"] = dict() random_state = np.random.RandomState(seed) for k, v in bounds.items(): ret["MD"][k] = random_state.uniform(v[0], v[1]) print("Random location: {}".format(ret["MD"])) ret["sampling_duration"] = 0 ret["samples"] = dict() ret["n_samples"] = 0 ret = PointEstimateSimulationPhase(replicates=replicates, region_size=region_size).run( inference_task, ret) ret = PlottingPhase(pdf=pdf, figsize=figsize, obs_data=obs_data, test_data=test_data, plot_data=plot_data).run(inference_task, ret) ret = GroundTruthErrorPhase(ground_truth=ground_truth).run( inference_task, ret) ret = PredictionErrorPhase(test_data=test_data).run( inference_task, ret) return ret
def test_list_output(): vsim = elfi.tools.vectorize(lsimulator) vsum = elfi.tools.vectorize(lsummary) v = vsim(np.array([[.2, .8], [.3, .7]])) assert is_array(v) assert not isinstance(v[0], list) vsim = elfi.tools.vectorize(lsimulator, dtype=False) v = vsim(np.array([[.2, .8], [.3, .7]])) assert is_array(v) assert isinstance(v[0], list) obs = lsimulator([.2, .8]) elfi.new_model() p = elfi.Prior('dirichlet', [2, 2]) sim = elfi.Simulator(vsim, p, observed=obs) S = elfi.Summary(vsum, sim) d = elfi.Distance('euclidean', S) pool = elfi.OutputPool(['sim']) rej = elfi.Rejection(d, batch_size=100, pool=pool, output_names=['sim']) sample = rej.sample(100, n_sim=1000) mean = np.mean(sample.samples['p'], axis=0) # Crude test assert mean[1] > mean[0]
def test_external_operation(): # Note that the test string has intentionally not uniform formatting with spaces elfi.new_model() op = elfi.tools.external_operation('echo 1 {0} 4 5 6 {seed}') constant = elfi.Constant(123) simulator = elfi.Simulator(op, constant) v = simulator.generate(1) assert np.array_equal(v[:5], [1, 123, 4, 5, 6]) # Can be pickled pickle.dumps(op)
def predict(self, data_test): elfi.new_model("SMC") prior = elfi.Prior(MVUniform, self.p_lower, self.p_upper) sim = elfi.Simulator(self.simulator, prior, observed=data_test, name='sim') SS = elfi.Summary(self.identity, sim, name='identity') d = elfi.Distance('euclidean', SS, name='d') smc = elfi.SMC(d, batch_size=1, seed=42) samples = smc.sample(self.n_particles, [self.threshold]) return samples.samples_array
def modified_experiment(grid_params, elfi_params, rl_params, bolfi_params, obs_data, test_data, plot_data, types, replicates, region_size, ground_truth, n_cores, path_max_len, pdf, figsize): elfi.new_model() model = get_model(method, grid_params, p.get_elfi_params(), rl_params, obs_data, path_max_len) inference_task = BolfiFactory(model, bolfi_params).get() ret = dict() ret["n_cores"] = n_cores ret = SamplingPhase().run(inference_task, ret) ret = PosteriorAnalysisPhase(types=types).run(inference_task, ret) return ret
def test_dict_output(): vsim = elfi.tools.vectorize(simulator) vsum = elfi.tools.vectorize(summary) obs = simulator([.2, .8]) elfi.new_model() p = elfi.Prior('dirichlet', [2, 2]) sim = elfi.Simulator(vsim, p, observed=obs) S = elfi.Summary(vsum, sim) d = elfi.Distance('euclidean', S) pool = elfi.OutputPool(['sim']) rej = elfi.Rejection(d, batch_size=100, pool=pool, output_names=['sim']) sample = rej.sample(100, n_sim=1000) mean = np.mean(sample.samples['p'], axis=0) # Crude test assert mean[1] > mean[0]
def __init__(self, generator=None, p_lower=None, p_upper=None, n_particles=100): self.p_lower = p_lower self.p_upper = p_upper self.n_particles = n_particles self.generator = generator self.model = elfi.new_model() self.threshold = 0.1 # %% acceptance threshold
def predict(self, data_test): elfi.new_model("BOLFI") prior = elfi.Prior(MVUniform, self.p_lower, self.p_upper) sim = elfi.Simulator(self.simulator, prior, observed=data_test, name='sim') SS = elfi.Summary(self.identity, sim, name='identity') d = elfi.Distance('euclidean', SS, name='d') log_d = elfi.Operation(np.log, d) bolfi = elfi.BOLFI(log_d, batch_size=1, initial_evidence=20, update_interval=10, acq_noise_var=self.p_lower.size * [0.1], bounds=None, seed=42) bolfi.fit(n_evidence=self.n_particles) post = bolfi.extract_posterior(-1.) samples = post.model.X return samples
def get_model(n_obs=150, true_params=None, seed=None): """Return an initialised bivariate g-and-k model. Parameters ---------- n_obs : int, optional Number of the observations. true_params : array_like, optional Parameters defining the model. seed : np.random.RandomState, optional Returns ------- elfi.ElfiModel """ m = elfi.new_model() # Initialising the parameters as in Drovandi & Pettitt (2011). if true_params is None: true_params = [3, 4, 1, 0.5, 1, 2, .5, .4, 0.6] # Initialising the prior settings as in Drovandi & Pettitt (2011). priors = [] priors.append(elfi.Prior('uniform', 0, 5, model=m, name='a1')) priors.append(elfi.Prior('uniform', 0, 5, model=m, name='a2')) priors.append(elfi.Prior('uniform', 0, 5, model=m, name='b1')) priors.append(elfi.Prior('uniform', 0, 5, model=m, name='b2')) priors.append(elfi.Prior('uniform', -5, 10, model=m, name='g1')) priors.append(elfi.Prior('uniform', -5, 10, model=m, name='g2')) priors.append(elfi.Prior('uniform', -.5, 5.5, model=m, name='k1')) priors.append(elfi.Prior('uniform', -.5, 5.5, model=m, name='k2')) EPS = np.finfo(float).eps priors.append( elfi.Prior('uniform', -1 + EPS, 2 - 2 * EPS, model=m, name='rho')) # Obtaining the observations. y_obs = BiGNK(*true_params, n_obs=n_obs, random_state=np.random.RandomState(seed)) # Defining the simulator. fn_simulator = partial(BiGNK, n_obs=n_obs) elfi.Simulator(fn_simulator, *priors, observed=y_obs, name='BiGNK') # Initialising the default summary statistics. default_ss = elfi.Summary(ss_robust, m['BiGNK'], name='ss_robust') # Using the customEuclidean distance function designed for # the summary statistics of shape (batch_size, dim_ss, dim_ss_point). elfi.Discrepancy(euclidean_multiss, default_ss, name='d') return m
def modified_experiment(grid_params, elfi_params, rl_params, bolfi_params, obs_data, test_data, plot_data, types, replicates, region_size, ground_truth, n_cores, path_max_len, obs_set_size, pdf, figsize): elfi.new_model() model = get_model(method, grid_params, p.get_elfi_params(), rl_params, obs_data, path_max_len, obs_set_size) inference_task = BolfiFactory(model, bolfi_params).get() ret = dict() ret["n_cores"] = n_cores ret = SamplingPhase().run(inference_task, ret) ret = PosteriorAnalysisPhase(types=types).run(inference_task, ret) ret["plots_logl"] = inference_task.plot_post(pdf, figsize) elfi.new_model() model = get_model("approx", grid_params, p.get_elfi_params(), rl_params, obs_data, path_max_len, obs_set_size) inference_task = BolfiFactory(model, bolfi_params).get() ret = PointEstimateSimulationPhase(replicates=replicates, region_size=region_size).run( inference_task, ret) ret = LikelihoodSamplesSimulationPhase(replicates=replicates).run( inference_task, ret) ret = PlottingPhase(pdf=pdf, figsize=figsize, obs_data=obs_data, test_data=test_data, plot_data=plot_data).run(inference_task, ret) ret = GroundTruthErrorPhase(ground_truth=ground_truth).run( inference_task, ret) ret = PredictionErrorPhase(test_data=test_data).run( inference_task, ret) return ret
def get_model(n_obs=50, true_params=None, seed=None): """Initialise the g-and-k model. Parameters ---------- n_obs : int, optional Number of the observations. true_params : array_like, optional Parameters defining the model. seed : np.random.RandomState, optional Returns ------- elfi.ElfiModel """ m = elfi.new_model() # Initialising the parameters as in Allingham et al. (2009). if true_params is None: true_params = [3, 1, 2, .5] # Initialising the prior settings as in Allingham et al. (2009). priors = [] priors.append(elfi.Prior('uniform', 0, 10, model=m, name='A')) priors.append(elfi.Prior('uniform', 0, 10, model=m, name='B')) priors.append(elfi.Prior('uniform', 0, 10, model=m, name='g')) priors.append(elfi.Prior('uniform', 0, 10, model=m, name='k')) # Obtaining the observations. y_obs = GNK(*true_params, n_obs=n_obs, random_state=np.random.RandomState(seed)) # Defining the simulator. fn_simulator = partial(GNK, n_obs=n_obs) elfi.Simulator(fn_simulator, *priors, observed=y_obs, name='GNK') # Initialising the summary statistics as in Allingham et al. (2009). default_ss = elfi.Summary(ss_order, m['GNK'], name='ss_order') # Using the multi-dimensional Euclidean distance function as # the summary statistics' implementations are designed for multi-dimensional cases. elfi.Discrepancy(euclidean_multiss, default_ss, name='d') return m
def get_model(self, n_obs=100, true_params=None, seed_obs=None): m = elfi.new_model() elfi.Prior('uniform', -2, 4, name='x') elfi.Prior('uniform', -2, 4, name='y') params = [m['x'], m['y']] if true_params is None: true_params = [[1.5, 1]] y_obs = self.func(*true_params, random_state=np.random.RandomState(seed_obs)) y_obs = [np.mean(y_obs), np.std(y_obs)] elfi.Simulator(self.func, *params, observed=y_obs, name='sim') # elfi.Summary(partial(np.mean, axis=1), m['sim'], name='Mean') # elfi.Summary(partial(np.std, axis=1), m['sim'], name='Std') elfi.Distance('euclidean', m['sim'], name='dist') return m
def get_model(self, n_obs=10, true_params=None, seed_obs=None): m = elfi.new_model() # Parameters: ns, kc, alpha, r_star, As # priors from Sinha and Souradeep 2006. elfi.Prior('uniform', 0.5, 1.0, name='ns') elfi.Prior('uniform', 1e-7, 1e-3, name='kc') elfi.Prior('uniform', 0., 10., name='alpha') elfi.Prior('uniform', 0., 1., name='r_star') elfi.Prior('uniform', 2.7, 1.3, name='As') params = [m['ns'], m['kc'], m['alpha'], m['r_star'], m['As']] if true_params is None: true_params = [[0.96, 0.0003, 0.58, 0.75, 3.35]] y_obs = self.func(*true_params, random_state=np.random.RandomState(seed_obs)) elfi.Simulator(self.func, *params, observed=y_obs, name='sim') elfi.Distance('euclidean', m['sim'], name='dist') return m
def get_model(n_obs=50, true_params=None, seed_obs=None, nd_mean=False, cov_matrix=None): """Return a Gaussian noise model. Parameters ---------- n_obs : int, optional true_params : list, optional Default parameter settings. seed_obs : int, optional Seed for the observed data generation. nd_mean : bool, optional Option to use an n-D mean Gaussian noise model. cov_matrix : array_like, optional Covariance matrix, a requirement for the nd_mean model. Returns ------- elfi.ElfiModel """ # Defining the default settings. if true_params is None: if nd_mean: true_params = [4, 4] # 2-D mean. else: true_params = [4, .4] # mean and standard deviation. # Choosing the simulator for both observations and simulations. if nd_mean: fn_simulator = partial(gauss_nd_mean, cov_matrix=cov_matrix, n_obs=n_obs) else: fn_simulator = partial(gauss, n_obs=n_obs) # Obtaining the observations. y_obs = fn_simulator(*true_params, n_obs=n_obs, random_state=np.random.RandomState(seed_obs)) m = elfi.new_model() # Initialising the priors. eps_prior = 5 # The longest distance from the median of an initialised prior's distribution. priors = [] if nd_mean: n_dim = len(true_params) for i in range(n_dim): name_prior = 'mu_{}'.format(i) prior_mu = elfi.Prior('uniform', true_params[i] - eps_prior, 2 * eps_prior, model=m, name=name_prior) priors.append(prior_mu) else: priors.append( elfi.Prior('uniform', true_params[0] - eps_prior, 2 * eps_prior, model=m, name='mu')) priors.append( elfi.Prior('truncnorm', np.amax([.01, true_params[1] - eps_prior]), 2 * eps_prior, model=m, name='sigma')) elfi.Simulator(fn_simulator, *priors, observed=y_obs, name='gauss') # Initialising the summary statistics. sumstats = [] sumstats.append(elfi.Summary(ss_mean, m['gauss'], name='ss_mean')) sumstats.append(elfi.Summary(ss_var, m['gauss'], name='ss_var')) # Choosing the discrepancy metric. if nd_mean: elfi.Discrepancy(euclidean_multidim, *sumstats, name='d') else: elfi.Distance('euclidean', *sumstats, name='d') return m
def test_romc2(): """Test ROMC at the simple 1D example.""" # the prior distribution class Prior: def rvs(self, size=None, random_state=None): # size from (BS,) -> (BS,1) if size is not None: size = np.concatenate((size, [1])) return ss.uniform(loc=-2.5, scale=5).rvs(size=size, random_state=random_state) def pdf(self, theta): return ss.uniform(loc=-2.5, scale=5).pdf(theta) def logpdf(self, theta): return ss.uniform(loc=-2.5, scale=5).logpdf(theta) # function for sampling from the likelihood def likelihood_sample(theta, seed=None): """Vectorized sampling from likelihood.""" assert isinstance(theta, np.ndarray) theta = theta.astype(np.float) samples = np.empty_like(theta) c = 0.5 - 0.5**4 tmp_theta = theta[theta <= -0.5] samples[theta <= -0.5] = ss.norm(loc=-tmp_theta - c, scale=1).rvs(random_state=seed) theta[theta <= -0.5] = np.inf tmp_theta = theta[theta <= 0.5] samples[theta <= 0.5] = ss.norm(loc=tmp_theta**4, scale=1).rvs(random_state=seed) theta[theta <= 0.5] = np.inf tmp_theta = theta[theta < np.inf] samples[theta < np.inf] = ss.norm(loc=tmp_theta - c, scale=1).rvs(random_state=seed) theta[theta < np.inf] = np.inf assert np.allclose(theta, np.inf) return samples # define the simulator def simulator(theta, dim, batch_size=10000, random_state=None): theta = np.repeat(theta, dim, -1) return likelihood_sample(theta, seed=random_state) data = np.array([0.]) dim = data.shape[0] # Define ELFI model elfi.new_model("1D_example") elfi_prior = elfi.Prior(Prior(), name="theta") elfi_simulator = elfi.Simulator(simulator, elfi_prior, dim, observed=np.expand_dims(data, 0), name="simulator") dist = elfi.Distance('euclidean', elfi_simulator, name="dist") # Define ROMC inference method bounds = [(-2.5, 2.5)] romc = elfi.ROMC(dist, bounds) # Bayesian Optimisation solution part n1 = 50 seed = 21 optimizer_args = {} use_bo = True romc.solve_problems(n1=n1, seed=seed, use_bo=use_bo, optimizer_args=optimizer_args) eps_filter = .75 fit_models = True use_surrogate = True fit_models_args = {"nof_points": 30} romc.estimate_regions(eps_filter=eps_filter, use_surrogate=use_surrogate, fit_models=fit_models, fit_models_args=fit_models_args) n2 = 100 romc.sample(n2=n2) # assert summary statistics of samples match the ground truth assert np.allclose(romc.compute_expectation(h=lambda x: np.squeeze(x)), 0, atol=.4) assert np.allclose(romc.compute_expectation(h=lambda x: np.squeeze(x)**2), 1.1, atol=.4)
def kisdi_model(population_filename): # (cumulative) deaths every day from 1st of march deaths = [0]*20 + [1, 1, 1, 1, 3, 4, 7, 9, 11, 13, 17, 17, 19, 20, 25, 27, 27, 34, 40, 42, 47, 49, 56, 59, 64, 72, 75] # In ICU # hospitalized = [np.nan]*24 + [22, 24, 32, 31, 41, 49, 56, 62, 65, 72, 73, # 76, 81, 83, 82, 82, 81, 80, 77, 74, 75, 75, 76] # total hospitalized hospitalized = [np.nan]*24 + [82, 96, 108, 112, 134, 143, 137, 159, 160, 180, 187, 209, 228, 231, 239, 244, 236, 235, 235, 230, 232, 226, 215] observed = np.array([list(zip(deaths, hospitalized))]) model = elfi.new_model() areas = set() with open(population_filename, newline='') as f: for row in csv.DictReader(f): areas.add(row['Area']) univariate_params = { 'beta_presymptomatic': stats.uniform(0, 1), 'beta_asymptomatic': stats.uniform(0, 1), 'beta_infected': stats.uniform(0, 1), 'pi': stats.beta(4, 6), 'kappa': stats.beta(2, 8), 'reciprocal_eta': stats.gamma(2.34, 5.0), 'reciprocal_alpha': stats.gamma(2., 5.0), 'reciprocal_theta': stats.gamma(8.0, 5.0), 'reciprocal_nu': stats.gamma(2.86, 5.0), 'reciprocal_rho': stats.gamma(5.0, 5.0), 'reciprocal_chi': stats.gamma(10.0, 5.0), 'reciprocal_delta': stats.gamma(7.0, 5.0), } multivar_params = { 'contact_y': stats.dirichlet([1, 1, 1]), 'contact_m': stats.dirichlet([1, 1, 1]), 'contact_o': stats.dirichlet([1, 1, 1]), } parameters = {} for k, v in itertools.chain( univariate_params.items(), multivar_params.items()): parameters[k] = elfi.Prior(v, name=k, model=model) initial_condition_parameters = {} for area in list(areas): for compartment in ['Exposed', 'Presymptomatic', 'Asymptomatic', 'Infected']: for age_group in ['Young', 'Adults', 'Elderly']: key = (area, compartment, age_group) initial_condition_parameters[key] = \ elfi.Constant(1, name=' '.join(key), model=model) # elfi.Prior(stats.uniform(0, 1000), name=' '.join(key), # model=model) sim_fun = elfi.tools.vectorize(simulate, constants=[0, 1, 2, 3, 4], dtype=np.float_) sim = elfi.Simulator(sim_fun, population_filename, list(areas), observed.shape[1], list(parameters), list(initial_condition_parameters), *parameters.values(), *initial_condition_parameters.values(), observed = observed) deaths = elfi.Summary(deaths_column, sim, model=model) hospitalized = elfi.Summary(hospitalized_column, sim, model=model) dist = elfi.Discrepancy(time_series_discrepancy, deaths, hospitalized, model=model) return model, dist,\ univariate_params, multivar_params, initial_condition_parameters
def teardown_method(self, method): """Refresh ELFI after the execution of the test class's each method.""" elfi.new_model()
likelihood = Likelihood() prior = Prior() factor = create_factor(x=data) Z = approximate_Z(factor, a, b) gt_posterior_pdf = create_gt_posterior(likelihood, prior, data, Z) ############# DEFINE ELFI MODEL ################## def simulator(theta, dim, batch_size=10000, random_state=None): likelihood = Likelihood() theta = np.repeat(theta, dim, -1) return likelihood.rvs(theta, seed=random_state) elfi.new_model("1D_example") elfi_prior = elfi.Prior(Prior(), name="theta") elfi_simulator = elfi.Simulator(simulator, elfi_prior, dim, observed=np.expand_dims(data, 0), name="simulator") dist = elfi.Distance('euclidean', elfi_simulator, name="dist") bounds = [(-2.5, 2.5)] dim = data.shape[-1] # Defines the ROMC inference method romc = elfi.ROMC(dist, bounds) romc1 = elfi.ROMC(dist, bounds) romc2 = elfi.ROMC(dist, bounds)
def start_all(variable_name, variable_num, quantile, f): f.write('{0} {1}\n'.format(variable_name, quantile)) seed = 20170530 np.random.seed(seed) # We set true parameters true_values = { 'p': 0.005, 'k': 1, 's': 0.0005, 'xC': 100, 'xE': 25, 'y': 100, 'yy': 0.01, 'n': 100, 'w': 100, 'd': 0.00005, 'bC': 0.03, 'bE': 0.03, 'am': 0.01, 'aM': 0.07 } number_of_samples = int(1 / sampling) full_range = np.arange(start, stop, sampling) all_x_range = np.array(full_range).reshape((1, len(full_range))) first_x_data, second_x_data, third_x_data = get_three_ranges( start, first_x_range, second_x_range, third_x_range, number_of_samples, full_range) pred_prey_model = ImprovedHandyModel() pred_prey_model.variable_num = variable_num # Plot the observed sequence for whole range y_obs = pred_prey_model.calculate_model(true_values, all_x_range) plt.figure(figsize=(11, 6)) plt.plot(all_x_range[0, :], y_obs[0, :]) # Points between these lines are training points plt.axvline(x=first_x_range, color='r') plt.axvline(x=second_x_range, color='r') plt.xlabel('X value as an argument for model') plt.ylabel('Y value of the model') plt.savefig('{0}_{1}_all.png'.format(variable_name, quantile)) plt.close() # We plot only training part train_data = pred_prey_model.calculate_model(true_values, second_x_data) plt.figure(figsize=(11, 6)) plt.xticks(np.arange(first_x_range, second_x_range, 1.0)) plt.plot(second_x_data[0, :], train_data[0, :]) plt.xlabel('X value as an argument for function') plt.ylabel('Y value of the function') plt.savefig('{0}_{1}_part.png'.format(variable_name, quantile)) plt.close() # MAGIC pred_prey_model.second_x_data = second_x_data elfi.new_model() # has to be this way, so the keys in result dict have parameter names xC = elfi.Prior(scipy.stats.uniform, true_values['xC'] - width * true_values['xC'], 2 * width * true_values['xC']) xE = elfi.Prior(scipy.stats.uniform, true_values['xE'] - width * true_values['xE'], 2 * width * true_values['xE']) y = elfi.Prior(scipy.stats.uniform, true_values['y'] - width * true_values['y'], 2 * width * true_values['y']) w = elfi.Prior(scipy.stats.uniform, true_values['w'] - width * true_values['w'], 2 * width * true_values['w']) k = elfi.Prior(scipy.stats.uniform, true_values['k'] - width * true_values['k'], 2 * width * true_values['k']) s = elfi.Prior(scipy.stats.uniform, true_values['s'] - width * true_values['s'], 2 * width * true_values['s']) p = elfi.Prior(scipy.stats.uniform, true_values['p'] - width * true_values['p'], 2 * width * true_values['p']) yy = elfi.Prior(scipy.stats.uniform, true_values['yy'] - width * true_values['yy'], 2 * width * true_values['yy']) n = elfi.Prior(scipy.stats.uniform, true_values['n'] - width * true_values['n'], 2 * width * true_values['n']) d = elfi.Prior(scipy.stats.uniform, true_values['d'] - width * true_values['d'], 2 * width * true_values['d']) bC = elfi.Prior(scipy.stats.uniform, true_values['bC'] - width * true_values['bC'], 2 * width * true_values['bC']) bE = elfi.Prior(scipy.stats.uniform, true_values['bE'] - width * true_values['bE'], 2 * width * true_values['bE']) am = elfi.Prior(scipy.stats.uniform, true_values['am'] - width * true_values['am'], 2 * width * true_values['am']) aM = elfi.Prior(scipy.stats.uniform, true_values['aM'] - width * true_values['aM'], 2 * width * true_values['aM']) # Define the simulator node with the MA2 model ,give the priors to it as arguments. Y = elfi.Simulator(pred_prey_model.model, p, k, s, xC, xE, y, yy, n, d, w, bC, bE, am, aM, observed=train_data) # Autocovariances as the summary statistics def autocov(x, lag=1): c = np.mean(x[:, lag:] * x[:, :-lag], axis=1) return c # Summary node is defined by giving the autocovariance function and the simulated data (also includes observed data) S1 = elfi.Summary(autocov, Y) S2 = elfi.Summary(autocov, Y, 2) # Calculating the squared distance (S1_sim-S1_obs)**2 + (S2_sim-S2_obs)**2 d = elfi.Distance('euclidean', S1, S2) # Instantiation of the Rejection Algorithm rej = elfi.Rejection(d, batch_size=batch_size_c, seed=seed) result = rej.sample(N, quantile=quantile) # Print sampled means of parameters print(result) # Final result of mean samples mean_results = {k: v.mean() for k, v in result.samples.items()} for key, value in mean_results.items(): print('{0}: {1}'.format(key, value)) f.write('{0}: {1}\n'.format(key, value)) y_obs = pred_prey_model.calculate_model(true_values, second_x_data) plt.figure(figsize=(11, 6)) plt.plot(y_obs.ravel(), label="observed") plt.plot(pred_prey_model.calculate_model(mean_results, second_x_data).ravel(), label="simulated") plt.legend(loc="upper left") plt.savefig('{0}_{1}_final_part.png'.format(variable_name, quantile)) plt.close() y_obs = pred_prey_model.calculate_model(true_values, all_x_range) plt.figure(figsize=(11, 6)) plt.plot(y_obs.ravel(), label="observed") all_results_predicted = pred_prey_model.calculate_model( mean_results, all_x_range) plt.plot(all_results_predicted.ravel(), label="simulated") plt.legend(loc="upper left") plt.savefig('{0}_{1}_final_all.png'.format(variable_name, quantile)) plt.close() def calculate_error(start, stop): calculate = 0 for i in range(start, stop, 1): calculate += (y_obs[0][i] - all_results_predicted[0][i])**2 return calculate aa = calculate_error(int(start + 1), int(first_x_range * number_of_samples)) bb = calculate_error(int(first_x_range * number_of_samples), int(second_x_range * number_of_samples)) cc = calculate_error(int(second_x_range * number_of_samples), int(third_x_range * number_of_samples)) f.write('{0}\n{1}\n{2}\n\n'.format(aa, bb, cc))
def setup_class(cls): """Refresh ELFI upon initialising the test class.""" elfi.new_model()
def get_model(self, n_obs=100, true_params=None, seed_obs=None): """Return a complete model in inference task. Parameters ---------- n_obs : int, optional observation length of the MA2 process true_params : list, optional parameters with which the observed data is generated seed_obs : int, optional seed for the observed data generation Returns ------- m : elfi.ElfiModel """ m = elfi.new_model() burden = elfi.Prior('normal', 200, 30, name='burden') joint = elfi.RandomVariable(ops.JointPrior, burden, self.mean_obs_bounds, self.t1_bound, self.a1_bound) # DummyPrior takes a marginal from the joint prior R2 = elfi.Prior(ops.DummyPrior, joint, 0, name='R2') R1 = elfi.Prior(ops.DummyPrior, joint, 1, name='R1') t1 = elfi.Prior(ops.DummyPrior, joint, 2, name='t1') # Turn the epidemiological parameters to rate parameters for the simulator d1 = elfi.Operation(ops.Rt_to_d, R1, t1) d2 = 5.95 a2 = elfi.Operation(operator.mul, R2, d2) a1 = elfi.Operation(ops.Rt_to_a, R1, t1) if true_params is None: y0_burden = 192 y0_R2 = 0.09 y0_R1 = 5.88 y0_t1 = 6.74 y0_d1 = ops.Rt_to_d(y0_R1, y0_t1) y0_a2 = operator.mul(y0_R2, d2) y0_a1 = ops.Rt_to_a(y0_R1, y0_t1) self.y0 = ops.simulator(y0_burden, y0_a2, d2, y0_a1, y0_d1, 2, self.cluster_size_bound, self.warmup_bounds) self.y0_sum = [self.y0['n_obs'], self.y0['n_clusters'], self.y0['largest'], self.y0['clusters'], self.y0['obs_times']] # Add the simulator sim = elfi.Simulator(ops.simulator, burden, a2, d2, a1, d1, 2, self.cluster_size_bound, self.warmup_bounds, observed=self.y0) # Summaries extracted from the simulator output n_obs = elfi.Summary(ops.pick, sim, 'n_obs') n_clusters = elfi.Summary(ops.pick, sim, 'n_clusters') largest = elfi.Summary(ops.pick, sim, 'largest') clusters = elfi.Summary(ops.pick, sim, 'clusters') obs_times = elfi.Summary(ops.pick, sim, 'obs_times') sim = elfi.Operation(ops.distance, n_obs, n_clusters, largest, clusters, obs_times, self.y0_sum, name = 'sim') # Distance dist = elfi.Discrepancy(ops.distance, n_obs, n_clusters, largest, clusters, obs_times, name = 'dist') return m