def test_sample(self): # setup backend dummy = 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) # define a distance function dist_calc = Euclidean(stat_calc) # create fake observed data y_obs = [np.array(9.8)] # use the rejection sampling scheme sampler = RejectionABC([self.model], [dist_calc], dummy, seed=1) journal = sampler.sample([y_obs], 10, 1, 10) mu_sample = np.array(journal.get_parameters()['mu']) sigma_sample = np.array(journal.get_parameters()['sigma']) # test shape of samples self.assertEqual(np.shape(mu_sample), (10, 1)) self.assertEqual(np.shape(sigma_sample), (10, 1)) # Compute posterior mean #self.assertAlmostEqual(np.average(np.asarray(samples[:,0])),1.22301,10e-2) self.assertLess(np.average(mu_sample) - 1.22301, 1e-2) self.assertLess(np.average(sigma_sample) - 6.992218, 10e-2) self.assertFalse(journal.number_of_simulations == 0)
def setUp(self): # setup backend dummy = 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 a stupid uniform model now self.model2 = Uniform([[0], [10]]) self.sampler = DrawFromPrior([self.model], dummy, seed=1) self.original_journal = self.sampler.sample(100) self.generate_from_journal = GenerateFromJournal([self.model], dummy, seed=2) self.generate_from_journal_2 = GenerateFromJournal([self.model2], dummy, seed=2) # expected mean values from bootstrapped samples: self.mu_mean = -0.2050921750330999 self.sigma_mean = 5.178647189918053 # expected mean values from subsampled samples: self.mu_mean_2 = -0.021275259024241676 self.sigma_mean_2 = 5.672004487129107
def instantiate_MA2_with_uniform_triangular_region(size=100, **kwargs): R1 = Uniform([[0], [1]], name='R1') R2 = Uniform([[0], [1]], name='R2') model = MA2Reparametrized([R1, R2], size=size, **kwargs) return model
def infer_parameters_abcsubsim(): # 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) # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(statistics_calculator) # define sampling scheme from abcpy.inferences import ABCsubsim sampler = ABCsubsim([height_weight_model], [distance_calculator], backend, seed=1) steps, n_samples, n_samples_per_param, chain_length = 2, 10, 1, 2 print('ABCsubsim Inferring') journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, chain_length) return journal
def setUp(self): if has_torch: self.net = createDefaultNN(2, 3)() self.net_with_scaler = ScalerAndNet(self.net, None) self.net_with_discard_wrapper = DiscardLastOutputNet(self.net) self.stat_calc = NeuralEmbedding(self.net) self.stat_calc_with_scaler = NeuralEmbedding(self.net_with_scaler) self.stat_calc_with_discard_wrapper = NeuralEmbedding( self.net_with_discard_wrapper) # reference input and output torch.random.manual_seed(1) self.tensor = torch.randn(1, 2) self.out = self.net(self.tensor) self.out_discard = self.net_with_discard_wrapper(self.tensor) # try now the statistics rescaling option: 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]) sampler = DrawFromPrior([self.model], BackendDummy(), seed=1) reference_parameters, reference_simulations = sampler.sample_par_sim_pairs( 30, 1) reference_simulations = reference_simulations.reshape( reference_simulations.shape[0], reference_simulations.shape[2]) self.stat_calc_rescaling = NeuralEmbedding( self.net, reference_simulations=reference_simulations, previous_statistics=Identity(degree=2)) if not has_torch: self.assertRaises(ImportError, NeuralEmbedding, None)
def infer_parameters_smcabc(): # define observation for true parameters mean=170, 65 rng = np.random.RandomState() 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]], ) mu1 = Uniform([[25], [100]], ) # define the model height_weight_model = NestedBivariateGaussian([mu0, mu1]) # define statistics from abcpy.statistics import Identity statistics_calculator = Identity(degree = 2, cross = False) # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(statistics_calculator) # define sampling scheme from abcpy.inferences import SMCABC sampler = SMCABC([height_weight_model], [distance_calculator], backend, seed=1) steps, n_samples, n_samples_per_param, epsilon = 2, 10, 1, 2000 journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, epsilon, full_output=1) return journal
def infer_parameters_sabc(): # 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) # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(statistics_calculator) # define sampling scheme from abcpy.inferences import SABC sampler = SABC([height_weight_model], [distance_calculator], backend, seed=1) steps, epsilon, n_samples, n_samples_per_param, beta, delta, v = 2, 40000, 10, 1, 2, 0.2, 0.3 ar_cutoff, resample, n_update, full_output = 0.1, None, None, 1 print('SABC Inferring') journal = sampler.sample([y_obs], steps, epsilon, n_samples, n_samples_per_param, beta, delta, v, ar_cutoff, resample, n_update, full_output) return journal
def setUp(self): class Mockobject(Normal): def __init__(self, parameters): super(Mockobject, self).__init__(parameters) def pdf(self, input_values, x): return x self.N1 = Uniform([[1.3], [1.55]], name='n1') self.N2 = Uniform([[self.N1], [1.60]], name='n2') self.N3 = Uniform([[2], [4]], name='n3') self.graph1 = Uniform([[self.N1], [self.N2]], name='graph1') self.graph2 = Uniform([[.5], [self.N3]]) self.graph = [self.graph1, self.graph2] statistics_calculator = Identity(degree=2, cross=False) distance_calculator = LogReg(statistics_calculator) backend = Backend() self.sampler1 = RejectionABC([self.graph1], [distance_calculator], backend) self.sampler2 = RejectionABC([self.graph2], [distance_calculator], backend) self.sampler3 = RejectionABC( self.graph, [distance_calculator, distance_calculator], backend) self.pdf1 = self.sampler1.pdf_of_prior(self.sampler1.model, [1.32088846, 1.42945274]) self.pdf2 = self.sampler2.pdf_of_prior(self.sampler2.model, [3]) self.pdf3 = self.sampler3.pdf_of_prior(self.sampler3.model, [1.32088846, 1.42945274, 3])
def infer_parameters_apmcabc(): # 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) # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(statistics_calculator) # define sampling scheme from abcpy.inferences import APMCABC sampler = APMCABC([height_weight_model], [distance_calculator], backend, seed=1) steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file = 2, 100, 1, 0.2, 0.03, 2.0, 1, None print('APMCABC Inferring') journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file) return journal
def infer_parameters(): # define observation for true parameters mean=170, std=15 height_obs = [ 160.82499176, 167.24266737, 185.71695756, 153.7045709, 163.40568812, 140.70658699, 169.59102084, 172.81041696, 187.38782738, 179.66358934, 176.63417241, 189.16082803, 181.98288443, 170.18565017, 183.78493886, 166.58387299, 161.9521899, 155.69213073, 156.17867343, 144.51580379, 170.29847515, 197.96767899, 153.36646527, 162.22710198, 158.70012047, 178.53470703, 170.77697743, 164.31392633, 165.88595994, 177.38083686, 146.67058471763457, 179.41946565658628, 238.02751620619537, 206.22458790620766, 220.89530574344568, 221.04082532837026, 142.25301427453394, 261.37656571434275, 171.63761180867033, 210.28121820385866, 237.29130237612236, 175.75558340169619, 224.54340549862235, 197.42448680731226, 165.88273684581381, 166.55094082844519, 229.54308602661584, 222.99844054358519, 185.30223966014586, 152.69149367593846, 206.94372818527413, 256.35498655339154, 165.43140916577741, 250.19273595481803, 148.87781549665536, 223.05547559193792, 230.03418198709608, 146.13611923127021, 138.24716809523139, 179.26755740864527, 141.21704876815426, 170.89587081800852, 222.96391329259626, 188.27229523693822, 202.67075179617672, 211.75963110985992, 217.45423324370509 ] # define prior from abcpy.continuousmodels import Uniform mu = Uniform([[150], [200]], ) sigma = Uniform([[5], [25]], ) # define the model from abcpy.continuousmodels import Normal as Gaussian height = Gaussian([mu, sigma], name='height') # define statistics from abcpy.statistics import Identity statistics_calculator = Identity(degree=2, cross=False) # define distance from abcpy.distances import LogReg distance_calculator = LogReg(statistics_calculator) # define kernel from abcpy.perturbationkernel import DefaultKernel kernel = DefaultKernel([mu, sigma]) # define backend # Note, the dummy backend does not parallelize the code! from abcpy.backends import BackendDummy as Backend backend = Backend() # define sampling scheme from abcpy.inferences import PMCABC sampler = PMCABC([height], [distance_calculator], backend, kernel, seed=1) # sample from scheme T, n_sample, n_samples_per_param = 3, 250, 10 eps_arr = np.array([.75]) epsilon_percentile = 10 journal = sampler.sample([height_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
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 setUp(self): self.stat_calc1 = Identity(degree=1, cross=0) self.stat_calc2 = Identity(degree=1, cross=0) self.distancefunc1 = Euclidean(self.stat_calc1) self.distancefunc2 = Euclidean(self.stat_calc2) ## Define Models # 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.model1 = Normal([mu, sigma]) self.model2 = Normal([mu, sigma]) #Check whether wrong sized distnacefuncs gives an error self.assertRaises(ValueError, LinearCombination, [self.model1, self.model2], [self.distancefunc1], [1.0, 1.0]) #Check whether wrong sized weights gives an error self.assertRaises(ValueError, LinearCombination, [self.model1, self.model2], [self.distancefunc1, self.distancefunc2], [1.0, 1.0, 1.0]) self.jointdistancefunc = LinearCombination( [self.model1, self.model2], [self.distancefunc1, self.distancefunc2], [1.0, 1.0])
def infer_parameters_pmcabc(): # 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) # define distance from abcpy.distances import Euclidean distance_calculator = Euclidean(statistics_calculator) # define sampling scheme from abcpy.inferences import PMCABC sampler = PMCABC([height_weight_model], [distance_calculator], backend, seed=1) # sample from scheme T, n_sample, n_samples_per_param = 2, 10, 1 eps_arr = np.array([10000]) epsilon_percentile = 95 print('PMCABC Inferring') journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) 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)
def setUp(self): self.mu = Uniform([[-5.0], [5.0]], name='mu') self.sigma = Uniform([[5.0], [10.0]], name='sigma') self.model = Normal([self.mu, self.sigma]) self.stat_calc = Identity(degree=2, cross=False) self.likfun = SynLikelihood(self.stat_calc) # create fake simulated data self.mu._fixed_values = [1.1] self.sigma._fixed_values = [1.0] self.y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1))
def setUp(self): self.mu = Uniform([[-5.0], [5.0]], name='mu') self.sigma = Uniform([[5.0], [10.0]], name='sigma') self.model = Normal([self.mu, self.sigma]) self.stat_calc = Identity(degree=2, cross=0) self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate=100, n_folds=10, max_iter=100000, seed=1)
def setUp(self): # define prior and model sigma = Uniform([[10], [20]]) mu = Normal([0, 1]) self.Y = Normal([mu, sigma]) # define backend self.backend = Backend() # define statistics self.statistics_cal = Identity(degree=3, cross=False) if has_torch: # Initialize statistics learning self.statisticslearning = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10, scale_samples=False) # with sample scaler: self.statisticslearning_with_scaler = SemiautomaticNN( [self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10, scale_samples=True)
def setUp(self): self.mu = Uniform([[-5.0], [5.0]], name='mu') self.sigma = Uniform([[5.0], [10.0]], name='sigma') self.model = Normal([self.mu, self.sigma]) self.model_bivariate = Uniform([[0, 0], [1, 1]], name="model") self.stat_calc = Identity(degree=2, cross=1) self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate=100, n_folds=10, max_iter=100000, seed=1) self.likfun_wrong_n_sim = PenLogReg(self.stat_calc, [self.model], n_simulate=10, n_folds=10, max_iter=100000, seed=1) self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate=100, n_folds=10, max_iter=100000, seed=1) self.y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1)) self.y_obs_bivariate = self.model_bivariate.forward_simulate( self.model_bivariate.get_input_values(), 1, rng=np.random.RandomState(1)) self.y_obs_double = self.model.forward_simulate( self.model.get_input_values(), 2, rng=np.random.RandomState(1)) self.y_obs_bivariate_double = self.model_bivariate.forward_simulate( self.model_bivariate.get_input_values(), 2, rng=np.random.RandomState(1)) # create fake simulated data self.mu._fixed_values = [1.1] self.sigma._fixed_values = [1.0] self.y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1)) self.y_sim_bivariate = self.model_bivariate.forward_simulate( self.model_bivariate.get_input_values(), 100, rng=np.random.RandomState(1))
def setUp(self): # find spark and initialize it self.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 a distance function stat_calc = Identity(degree=2, cross=0) self.dist_calc = Euclidean(stat_calc) # create fake observed data #self.observation = self.model.forward_simulate(1, np.random.RandomState(1))[0].tolist() self.observation = [np.array(9.8)]
def setUp(self): self.stat_calc1 = Identity(degree = 1, cross = 0) self.stat_calc2 = Identity(degree= 1, cross = 0) self.likfun1 = SynLikelihood(self.stat_calc1) self.likfun2 = SynLikelihood(self.stat_calc2) ## Define Models # define a uniform prior distribution self.mu = Uniform([[-5.0], [5.0]], name='mu') self.sigma = Uniform([[0.0], [10.0]], name='sigma') # define a Gaussian model self.model1 = Normal([self.mu,self.sigma]) self.model2 = Normal([self.mu,self.sigma]) #Check whether wrong sized distnacefuncs gives an error self.assertRaises(ValueError, ProductCombination, [self.model1,self.model2], [self.likfun1]) self.jointapprox_lhd = ProductCombination([self.model1, self.model2], [self.likfun1, self.likfun2])
def setUp(self): # define observation for true parameters mean=170, std=15 self.y_obs = [160.82499176] self.model_array = [None] * 2 # Model 1: Gaussian # define prior self.mu1 = Uniform([[150], [200]], name='mu1') self.sigma1 = Uniform([[5.0], [25.0]], name='sigma1') # define the model self.model_array[0] = Normal([self.mu1, self.sigma1]) # Model 2: Student t # define prior self.mu2 = Uniform([[150], [200]], name='mu2') self.sigma2 = Uniform([[1], [30.0]], name='sigma2') # define the model self.model_array[1] = StudentT([self.mu2, self.sigma2]) # define statistics self.statistics_calc = Identity(degree=2, cross=False) # define backend self.backend = Backend()
def setUp(self): self.coeff = np.array([[3, 4], [5, 6]]) self.stat_calc = LinearTransformation(self.coeff, degree=1, cross=False) # try now the statistics rescaling option: 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]) sampler = DrawFromPrior([self.model], BackendDummy(), seed=1) reference_parameters, reference_simulations = sampler.sample_par_sim_pairs( 30, 1) reference_simulations = reference_simulations.reshape( reference_simulations.shape[0], reference_simulations.shape[2]) reference_simulations_double = np.concatenate( [reference_simulations, reference_simulations], axis=1) self.stat_calc_rescaling = LinearTransformation( self.coeff, reference_simulations=reference_simulations_double)
def infer_model(): # define observation for true parameters mean=170, std=15 y_obs = [160.82499176] ## Create a array of models from abcpy.continuousmodels import Uniform, Normal, StudentT model_array = [None] * 2 #Model 1: Gaussian mu1 = Uniform([[150], [200]], name='mu1') sigma1 = Uniform([[5.0], [25.0]], name='sigma1') model_array[0] = Normal([mu1, sigma1]) #Model 2: Student t mu2 = Uniform([[150], [200]], name='mu2') sigma2 = Uniform([[1], [30.0]], name='sigma2') model_array[1] = StudentT([mu2, sigma2]) # define statistics from abcpy.statistics import Identity statistics_calculator = Identity(degree=2, cross=False) # define backend from abcpy.backends import BackendDummy as Backend backend = Backend() # Initiate the Model selection scheme modelselection = RandomForest(model_array, statistics_calculator, backend, seed=1) # Choose the correct model model = modelselection.select_model(y_obs, n_samples=100, n_samples_per_param=1) # Compute the posterior probability of each of the models model_prob = modelselection.posterior_probability(y_obs)
def infer_parameters(model_num, synthetic, T, n_sample, ar_cutoff): y_obs = [0] #prior = Uniform([[0, 0, 0, 0], [5, 5, 2.5, 2.5]]) prior1 = Uniform([[0], [5]]) prior2 = Uniform([[0], [5]]) prior3 = Uniform([[0], [2.5]]) prior4 = Uniform([[0], [2.5]]) model = Airport([prior1, prior2, prior3, prior4], name="Airport", model_num=model_num, synthetic=synthetic) from abcpy.statistics import Identity statistics_calculator = Identity(degree=1, cross=False) from abcpy.distances import Euclidean distance_calculator = Euclidean(statistics_calculator) # define sampling scheme from abcpy.inferences import SABC sampler = SABC([model], [distance_calculator], backend) # define sampling scheme #from abcpy.inferences import PMCABC #sampler = PMCABC([model], [distance_calculator], backend, kernel, seed=1) # sample from scheme journal = sampler.sample([y_obs], T, 1000, n_sample, 1, ar_cutoff=ar_cutoff) return journal
def setUp(self): self.stat_calc = Identity(degree=1, cross=False) self.stat_calc_pipeline = Identity(degree=2, cross=False, previous_statistics=self.stat_calc) # try now the statistics rescaling option: 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]) sampler = DrawFromPrior([self.model], BackendDummy(), seed=1) reference_parameters, reference_simulations = sampler.sample_par_sim_pairs( 30, 1) reference_simulations = reference_simulations.reshape( reference_simulations.shape[0], reference_simulations.shape[2]) reference_simulations_double = np.concatenate( [reference_simulations, reference_simulations], axis=1) self.stat_calc_rescaling = Identity( reference_simulations=reference_simulations_double) self.stat_calc_rescaling_2 = Identity( reference_simulations=reference_simulations)
def setUp(self): # define prior and model sigma = Uniform([[10], [20]]) mu = Normal([0, 1]) Y = Normal([mu, sigma]) # define backend self.backend = Backend() # define statistics self.statistics_cal = Identity(degree = 3, cross = False) # Initialize summaryselection self.summaryselection = Semiautomatic([Y], self.statistics_cal, self.backend, n_samples = 1000, n_samples_per_param = 1, seed = 1)
class PenLogRegTests(unittest.TestCase): def setUp(self): self.mu = Uniform([[-5.0], [5.0]], name='mu') self.sigma = Uniform([[5.0], [10.0]], name='sigma') self.model = Normal([self.mu, self.sigma]) self.model_bivariate = Uniform([[0, 0], [1, 1]], name="model") self.stat_calc = Identity(degree=2, cross=1) self.likfun = PenLogReg(self.stat_calc, [self.model], n_simulate=100, n_folds=10, max_iter=100000, seed=1) self.likfun_wrong_n_sim = PenLogReg(self.stat_calc, [self.model], n_simulate=10, n_folds=10, max_iter=100000, seed=1) self.likfun_bivariate = PenLogReg(self.stat_calc, [self.model_bivariate], n_simulate=100, n_folds=10, max_iter=100000, seed=1) self.y_obs = self.model.forward_simulate(self.model.get_input_values(), 1, rng=np.random.RandomState(1)) self.y_obs_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 1, rng=np.random.RandomState(1)) self.y_obs_double = self.model.forward_simulate(self.model.get_input_values(), 2, rng=np.random.RandomState(1)) self.y_obs_bivariate_double = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 2, rng=np.random.RandomState(1)) # create fake simulated data self.mu._fixed_values = [1.1] self.sigma._fixed_values = [1.0] self.y_sim = self.model.forward_simulate(self.model.get_input_values(), 100, rng=np.random.RandomState(1)) self.y_sim_bivariate = self.model_bivariate.forward_simulate(self.model_bivariate.get_input_values(), 100, rng=np.random.RandomState(1)) def test_likelihood(self): # Checks whether wrong input type produces error message self.assertRaises(TypeError, self.likfun.loglikelihood, 3.4, [2, 1]) self.assertRaises(TypeError, self.likfun.loglikelihood, [2, 4], 3.4) # create observed data comp_likelihood = self.likfun.loglikelihood(self.y_obs, self.y_sim) expected_likelihood = 9.77317308598673e-08 # This checks whether it computes a correct value and dimension is right. Not correct as it does not check the # absolute value: # self.assertLess(comp_likelihood - expected_likelihood, 10e-2) self.assertAlmostEqual(comp_likelihood, np.log(expected_likelihood)) # check if it returns the correct error when n_samples does not match: self.assertRaises(RuntimeError, self.likfun_wrong_n_sim.loglikelihood, self.y_obs, self.y_sim) # try now with the bivariate uniform model: comp_likelihood_biv = self.likfun_bivariate.loglikelihood(self.y_obs_bivariate, self.y_sim_bivariate) expected_likelihood_biv = 0.999999999999999 self.assertAlmostEqual(comp_likelihood_biv, np.log(expected_likelihood_biv)) def test_likelihood_multiple_observations(self): comp_likelihood = self.likfun.loglikelihood(self.y_obs, self.y_sim) expected_likelihood = 9.77317308598673e-08 self.assertAlmostEqual(comp_likelihood, np.log(expected_likelihood)) expected_likelihood_biv = 0.9999999999999979 comp_likelihood_biv = self.likfun_bivariate.loglikelihood(self.y_obs_bivariate, self.y_sim_bivariate) self.assertAlmostEqual(comp_likelihood_biv, np.log(expected_likelihood_biv))
def formatted_prior(self): param_prior_sampler = [] for prior in self.priors_over_hood: prior_type = prior[1] param_name = prior[0] if prior_type == 'u': low, high = prior[2][0], prior[2][1] new_prior = Uniform([[low], [high]], name=param_name) elif prior_type == 'g': mean, sigma = prior[2][0], prior[2][1] new_prior = Normal([[mean], [sigma]], name=param_name) else: raise Exception('prior type ' + str(prior_type) + ' not valid') param_prior_sampler.append(new_prior) return param_prior_sampler
def setUp(self): # define prior and model sigma = Uniform([[10], [20]]) mu = Normal([0, 1]) self.Y = Normal([mu, sigma]) # define backend self.backend = Backend() # define statistics self.statistics_cal = Identity(degree=3, cross=False) if has_torch: # Initialize statistics learning self.statisticslearning = TripletDistanceLearning( [self.Y], self.statistics_cal, self.backend, n_samples=100, n_samples_per_param=1, seed=1, n_epochs=10)
import numpy as np from abcpy.statistics import Identity from Distance import Abserror from abcpy.inferences import APMCABC from abcpy.continuousmodels import Uniform from Model import TIP4PGromacsOOOH as Water # Define Graphical model theta1 = Uniform([[.281] , [.53]],name='theta1') theta2 = Uniform([[0.2] , [0.9]],name='theta2') water = Water([theta1, theta2, 2500000]) # Define distance and statistics statistics_calculator = Identity(degree = 1, cross = False) distance_calculator = Abserror(statistics_calculator) # Define kernel from abcpy.backends import BackendMPI as Backend backend = Backend() from abcpy.perturbationkernel import DefaultKernel kernel = DefaultKernel([theta1, theta2]) ######### Inference for simulated data ############### water_obs = [np.load('Data/obs_data.npy')] sampler = APMCABC([water], [distance_calculator], backend, kernel, seed = 1) steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file =10, 100, 1, 0.1, 0.03, 2.0, 1, None print('TIP4P: APMCABC Inferring for simulated data') journal_apmcabc = sampler.sample([water_obs], steps, n_samples, n_samples_per_param, alpha, acceptance_cutoff, covFactor, full_output, journal_file)