def infer_parameters_pmc(): # define observation for true parameters mean=170, 65 rng = np.random.RandomState(seed=1) y_obs = [np.array(rng.multivariate_normal([170, 65], np.eye(2), 1).reshape(2, ))] # define prior from abcpy.continuousmodels import Uniform mu0 = Uniform([[150], [200]], name="mu0") mu1 = Uniform([[25], [100]], name="mu1") # define the model height_weight_model = NestedBivariateGaussian([mu0, mu1]) # define statistics from abcpy.statistics import Identity statistics_calculator = Identity(degree=2, cross=False) from abcpy.approx_lhd import SynLikelihood approx_lhd = SynLikelihood(statistics_calculator) # define sampling scheme from abcpy.inferences import PMC sampler = PMC([height_weight_model], [approx_lhd], backend, seed=2) # sample from scheme T, n_sample, n_samples_per_param = 2, 10, 10 print('PMC Inferring') journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param) return journal
def test_sample(self): # setup backend backend = BackendDummy() # define a uniform prior distribution mu = Uniform([[-5.0], [5.0]], name='mu') sigma = Uniform([[0.0], [10.0]], name='sigma') # define a Gaussian model self.model = Normal([mu,sigma]) # define sufficient statistics for the model stat_calc = Identity(degree = 2, cross = 0) # create fake observed data #y_obs = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist() y_obs = [np.array(9.8)] # Define the likelihood function likfun = SynLiklihood(stat_calc) T, n_sample, n_samples_per_param = 1, 10, 100 sampler = PMC([self.model], [likfun], backend, seed = 1) journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors = np.array([.1,.1]), iniPoints = None) mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights()) # Compute posterior mean mu_post_mean, sigma_post_mean = np.average(mu_post_sample, weights=post_weights, axis=0), np.average(sigma_post_sample, weights=post_weights, axis=0) # test shape of sample mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape(mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights) self.assertEqual(mu_sample_shape, (10,1)) self.assertEqual(sigma_sample_shape, (10,1)) self.assertEqual(weights_sample_shape, (10,1)) self.assertLess(abs(mu_post_mean - (-3.402868)), 1e-3) self.assertLess(abs(sigma_post_mean - 6.212), 1e-3) self.assertFalse(journal.number_of_simulations == 0) # use the PMC scheme for T = 2 T, n_sample, n_samples_per_param = 2, 10, 100 sampler = PMC([self.model], [likfun], backend, seed = 1) journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors = np.array([.1,.1]), iniPoints = None) mu_post_sample, sigma_post_sample, post_weights = np.array(journal.get_parameters()['mu']), np.array(journal.get_parameters()['sigma']), np.array(journal.get_weights()) # Compute posterior mean mu_post_mean, sigma_post_mean = np.average(mu_post_sample, weights=post_weights, axis=0), np.average(sigma_post_sample, weights=post_weights, axis=0) # test shape of sample mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape(mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights) self.assertEqual(mu_sample_shape, (10,1)) self.assertEqual(sigma_sample_shape, (10,1)) self.assertEqual(weights_sample_shape, (10,1)) self.assertLess(abs(mu_post_mean - (-3.03325763) ), 1e-3) self.assertLess(abs(sigma_post_mean - 6.92124735), 1e-3) self.assertFalse(journal.number_of_simulations == 0)
elif technique == "RE": # for the RE approach: it is better to use pairwise combinations of the statistics in order to make comparison with # SL fair statistic = Identity( cross=True, previous_statistics=statistic, degree=1) # this should automatically use the pairwise comb. # when instantiating this, it takes additional parameters; does it simulate from the model immediately? approx_lhd = PenLogReg(statistic, [ABC_model], n_samples_per_param, n_folds=10, max_iter=100000, seed=seed) else: raise NotImplementedError sampler = PMC([ABC_model], [approx_lhd], backend, seed=seed) wass_dist_array = np.zeros(n_observations) RMSE_post_mean = np.zeros(n_observations) running_time_inference = np.zeros(n_observations) namefile_postfix_no_index = "_steps_{}_n_samples_{}_n_samples_per_param_{}".format( steps, n_samples, n_samples_per_param) if perform_postprocessing: theta_test = np.zeros( (n_observations - start_observation_index, theta_dim)) traces = np.zeros( (n_samples, n_observations - start_observation_index, theta_dim)) for obs_index in range(start_observation_index, n_observations): print("Observation {}".format(obs_index + 1))
def infer_parameters(): # The data corresponding to model_1 defined below grades_obs = [ 3.872486707973337, 4.6735380808674405, 3.9703538990858376, 4.11021272048805, 4.211048655421368, 4.154817956586653, 4.0046893064392695, 4.01891381384729, 4.123804757702919, 4.014941267301294, 3.888174595940634, 4.185275142948246, 4.55148774469135, 3.8954427675259016, 4.229264035335705, 3.839949451328312, 4.039402553532825, 4.128077814241238, 4.361488645531874, 4.086279074446419, 4.370801602256129, 3.7431697332475466, 4.459454162392378, 3.8873973643008255, 4.302566721487124, 4.05556051626865, 4.128817316703757, 3.8673704442215984, 4.2174459453805015, 4.202280254493361, 4.072851400451234, 3.795173229398952, 4.310702877332585, 4.376886328810306, 4.183704734748868, 4.332192463368128, 3.9071312388426587, 4.311681374107893, 3.55187913252144, 3.318878360783221, 4.187850500877817, 4.207923106081567, 4.190462065625179, 4.2341474252986036, 4.110228694304768, 4.1589891480847765, 4.0345604687633045, 4.090635481715123, 3.1384654393449294, 4.20375641386518, 4.150452690356067, 4.015304457401275, 3.9635442007388195, 4.075915739179875, 3.5702080541929284, 4.722333310410388, 3.9087618197155227, 4.3990088006390735, 3.968501165774181, 4.047603645360087, 4.109184340976979, 4.132424805281853, 4.444358334346812, 4.097211737683927, 4.288553086265748, 3.8668863066511303, 3.8837108501541007 ] # The prior information changing the class size and social background, depending on school location from abcpy.continuousmodels import Uniform, Normal school_location = Uniform([[0.2], [0.3]], ) # The average class size of a certain school class_size = Normal([[school_location], [0.1]], ) # The social background of a student background = Normal([[school_location], [0.1]], ) # The grade a student would receive without any bias grade_without_additional_effects = Normal([[4.5], [0.25]], ) # The grade a student of a certain school receives final_grade = grade_without_additional_effects - class_size - background # The data corresponding to model_2 defined below scholarship_obs = [ 2.7179657436207805, 2.124647285937229, 3.07193407853297, 2.335024761813643, 2.871893855192, 3.4332002458233837, 3.649996835818173, 3.50292335102711, 2.815638168018455, 2.3581613289315992, 2.2794821846395568, 2.8725835459926503, 3.5588573782815685, 2.26053126526137, 1.8998143530749971, 2.101110815311782, 2.3482974964831573, 2.2707679029919206, 2.4624550491079225, 2.867017757972507, 3.204249152084959, 2.4489542437714213, 1.875415915801106, 2.5604889644872433, 3.891985093269989, 2.7233633223405205, 2.2861070389383533, 2.9758813233490082, 3.1183403287267755, 2.911814060853062, 2.60896794303205, 3.5717098647480316, 3.3355752461779824, 1.99172284546858, 2.339937680892163, 2.9835630207301636, 2.1684912355975774, 3.014847335983034, 2.7844122961916202, 2.752119871525148, 2.1567428931391635, 2.5803629307680644, 2.7326646074552103, 2.559237193255186, 3.13478196958166, 2.388760269933492, 3.2822443541491815, 2.0114405441787437, 3.0380056368041073, 2.4889680313769724, 2.821660164621084, 3.343985964873723, 3.1866861970287808, 4.4535037154856045, 3.0026333138006027, 2.0675706089352612, 2.3835301730913185, 2.584208398359566, 3.288077633446465, 2.6955853384148183, 2.918315169739928, 3.2464814419322985, 2.1601516779909433, 3.231003347780546, 1.0893224045062178, 0.8032302688764734, 2.868438615047827 ] # A quantity that determines whether a student will receive a scholarship scholarship_without_additional_effects = Normal([[2], [0.5]], ) # A quantity determining whether a student receives a scholarship, including his social background final_scholarship = scholarship_without_additional_effects + 3 * background # Define a summary statistics for final grade and final scholarship from abcpy.statistics import Identity statistics_calculator_final_grade = Identity(degree=2, cross=False) statistics_calculator_final_scholarship = Identity(degree=3, cross=False) # Define a distance measure for final grade and final scholarship from abcpy.approx_lhd import SynLikelihood approx_lhd_final_grade = SynLikelihood(statistics_calculator_final_grade) approx_lhd_final_scholarship = SynLikelihood( statistics_calculator_final_scholarship) # Define a backend from abcpy.backends import BackendDummy as Backend backend = Backend() # Define a perturbation kernel from abcpy.perturbationkernel import DefaultKernel kernel = DefaultKernel([school_location, class_size, grade_without_additional_effects, \ background, scholarship_without_additional_effects]) # Define sampling parameters T, n_sample, n_samples_per_param = 3, 250, 10 # Define sampler from abcpy.inferences import PMC sampler = PMC([final_grade, final_scholarship], \ [approx_lhd_final_grade, approx_lhd_final_scholarship], backend, kernel) # Sample journal = sampler.sample([grades_obs, scholarship_obs], T, n_sample, n_samples_per_param)
def test_sample(self): # setup backend backend = BackendDummy() # define a uniform prior distribution mu = Uniform([[-5.0], [5.0]], name='mu') sigma = Uniform([[0.0], [10.0]], name='sigma') # define a Gaussian model self.model = Normal([mu, sigma]) # define sufficient statistics for the model stat_calc = Identity(degree=2, cross=0) # create fake observed data #y_obs = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist() y_obs = [np.array(9.8)] # Define the likelihood function likfun = SynLiklihood(stat_calc) T, n_sample, n_samples_per_param = 1, 10, 100 sampler = PMC([self.model], [likfun], backend, seed=1) journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors=np.array([.1, .1]), iniPoints=None) mu_post_sample, sigma_post_sample, post_weights = np.array( journal.get_parameters()['mu']), np.array( journal.get_parameters()['sigma']), np.array( journal.get_weights()) # Compute posterior mean mu_post_mean, sigma_post_mean = journal.posterior_mean( )['mu'], journal.posterior_mean()['sigma'] # test shape of sample mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \ (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape self.assertEqual(mu_sample_shape, (10, 1)) self.assertEqual(sigma_sample_shape, (10, 1)) self.assertEqual(weights_sample_shape, (10, 1)) self.assertLess(abs(mu_post_mean - (-3.3711206204663764)), 1e-3) self.assertLess(abs(sigma_post_mean - 6.518520667688998), 1e-3) self.assertFalse(journal.number_of_simulations == 0) # use the PMC scheme for T = 2 T, n_sample, n_samples_per_param = 2, 10, 100 sampler = PMC([self.model], [likfun], backend, seed=1) journal = sampler.sample([y_obs], T, n_sample, n_samples_per_param, covFactors=np.array([.1, .1]), iniPoints=None) mu_post_sample, sigma_post_sample, post_weights = np.array( journal.get_parameters()['mu']), np.array( journal.get_parameters()['sigma']), np.array( journal.get_weights()) # Compute posterior mean mu_post_mean, sigma_post_mean = journal.posterior_mean( )['mu'], journal.posterior_mean()['sigma'] # test shape of sample mu_sample_shape, sigma_sample_shape, weights_sample_shape = (len(mu_post_sample), mu_post_sample[0].shape[1]), \ (len(sigma_post_sample), sigma_post_sample[0].shape[1]), post_weights.shape self.assertEqual(mu_sample_shape, (10, 1)) self.assertEqual(sigma_sample_shape, (10, 1)) self.assertEqual(weights_sample_shape, (10, 1)) self.assertLess(abs(mu_post_mean - (-2.970827684425406)), 1e-3) self.assertLess(abs(sigma_post_mean - 6.82165619013458), 1e-3) self.assertFalse(journal.number_of_simulations == 0)
def test_sample(self): # setup backend backend = BackendDummy() # define a uniform prior distribution lb = np.array([-5, 0]) ub = np.array([5, 10]) prior = Uniform(lb, ub, seed=1) # define a Gaussian model model = Gaussian(prior, mu=2.1, sigma=5.0, seed=1) # define sufficient statistics for the model stat_calc = Identity(degree=2, cross=0) # create fake observed data y_obs = model.simulate(1) # Define the likelihood function likfun = SynLiklihood(stat_calc) # use the PMC scheme for T = 1 mean = np.array([-13.0, .0, 7.0]) cov = np.eye(3) kernel = MultiNormal(mean, cov, seed=1) T, n_sample, n_samples_per_param = 1, 10, 100 sampler = PMC(model, likfun, kernel, backend, seed=1) journal = sampler.sample(y_obs, T, n_sample, n_samples_per_param, covFactor=np.array([.1, .1]), iniPoints=None) samples = (journal.get_parameters(), journal.get_weights()) # Compute posterior mean mu_post_sample, sigma_post_sample, post_weights = np.array( samples[0][:, 0]), np.array(samples[0][:, 1]), np.array(samples[1][:, 0]) mu_post_mean, sigma_post_mean = np.average( mu_post_sample, weights=post_weights), np.average(sigma_post_sample, weights=post_weights) # test shape of sample mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape( mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights) self.assertEqual(mu_sample_shape, (10, )) self.assertEqual(sigma_sample_shape, (10, )) self.assertEqual(weights_sample_shape, (10, )) self.assertLess(abs(mu_post_mean - (-1.48953333102)), 1e-10) self.assertLess(abs(sigma_post_mean - 6.50695612708), 1e-10) # use the PMC scheme for T = 2 T, n_sample, n_samples_per_param = 2, 10, 100 sampler = PMC(model, likfun, kernel, backend, seed=1) journal = sampler.sample(y_obs, T, n_sample, n_samples_per_param, covFactor=np.array([.1, .1]), iniPoints=None) samples = (journal.get_parameters(), journal.get_weights()) # Compute posterior mean mu_post_sample, sigma_post_sample, post_weights = np.asarray( samples[0][:, 0]), np.asarray(samples[0][:, 1]), np.asarray( samples[1][:, 0]) mu_post_mean, sigma_post_mean = np.average( mu_post_sample, weights=post_weights), np.average(sigma_post_sample, weights=post_weights) # test shape of sample mu_sample_shape, sigma_sample_shape, weights_sample_shape = np.shape( mu_post_sample), np.shape(mu_post_sample), np.shape(post_weights) self.assertEqual(mu_sample_shape, (10, )) self.assertEqual(sigma_sample_shape, (10, )) self.assertEqual(weights_sample_shape, (10, )) self.assertLess(abs(mu_post_mean - (-1.4033145848)), 1e-10) self.assertLess(abs(sigma_post_mean - 7.05175546876), 1e-10)