def infer_parameters(backend, steps=3, n_sample=250, n_samples_per_param=10, logging_level=logging.WARN): logging.basicConfig(level=logging_level) # 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]], name='mu') sigma = Uniform([[5], [25]], name='sigma') # define the model from abcpy.continuousmodels import Normal height = Normal([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, seed=42) # define sampling scheme from abcpy.inferences import PMCABC sampler = PMCABC([height], [distance_calculator], backend, seed=1) # sample from scheme eps_arr = np.array([.75]) epsilon_percentile = 10 journal = sampler.sample([height_obs], steps, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
def setUp(self): self.stat_calc1 = Identity(degree=1, cross=0) self.stat_calc2 = Identity(degree=1, cross=0) self.likfun1 = SynLiklihood(self.stat_calc1) self.likfun2 = SynLiklihood(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): 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): self.prior = Uniform([-5.0, 5.0], [5.0, 10.0], seed=1) self.model = Gaussian(self.prior, mu=1.1, sigma=1.0, seed=1) 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): 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.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 test(self): N1 = Normal([1, 0.1]) N2 = Normal([N1, 0.1]) N2.visited = True N1.visited = True statistics_calculator = Identity(degree=2, cross=False) distance_calculator = LogReg(statistics_calculator) backend = Backend() sampler = RejectionABC([N2], [distance_calculator], backend) sampler._reset_flags() self.assertFalse(N1.visited) self.assertFalse(N2.visited)
def setUp(self): self.B1 = Binomial([10, 0.2]) self.N1 = Normal([0.03, 0.01]) self.N2 = Normal([0.1, self.N1]) self.graph = Normal([self.B1, self.N2]) statistics_calculator = Identity(degree=2, cross=False) distance_calculator = LogReg(statistics_calculator) backend = Backend() self.sampler = RejectionABC([self.graph], [distance_calculator], backend) self.rng = np.random.RandomState(1) self.sampler.sample_from_prior(rng=self.rng)
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.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): # 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_val=100, n_samples_per_param=1, seed=1, n_epochs=2, scale_samples=False, use_tqdm=False) self.statisticslearning2 = SemiautomaticNN([self.Y], self.statistics_cal, self.backend, n_samples=10, n_samples_val=10, n_samples_per_param=1, seed=1, n_epochs=5, scale_samples=False, use_tqdm=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=2, scale_samples=True, use_tqdm=False)
def test(self): B1 = Binomial([10, 0.2]) N1 = Normal([0.03, 0.01]) N2 = Normal([0.1, N1]) graph = Normal([B1, N2]) statistics_calculator = Identity(degree=2, cross=False) distance_calculator = LogReg(statistics_calculator) backend = Backend() sampler = RejectionABC([graph], [distance_calculator], backend) rng = np.random.RandomState(1) sampler.sample_from_prior(rng=rng) self.assertIsNotNone(B1._fixed_values) self.assertIsNotNone(N1._fixed_values) self.assertIsNotNone(N2._fixed_values)
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 statistics learning self.statisticslearning = Semiautomatic([Y], self.statistics_cal, self.backend, n_samples=1000, n_samples_per_param=1, seed=1)
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 prior = Uniform([150, 5], [200, 25]) # define the model self.model_array[0] = Gaussian(prior, seed=1) #Model 2: Student t # define prior prior = Uniform([150, 1], [200, 30]) # define the model self.model_array[1] = Student_t(prior, seed=1) # define statistics self.statistics_calc = Identity(degree=2, cross=False) # define backend self.backend = Backend()
def infer_parameters_rsmcabc(): # 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 RSMCABC sampler = RSMCABC([height_weight_model], [distance_calculator], backend, seed=1) print('sampling') steps, n_samples, n_samples_per_param, alpha, epsilon_init, epsilon_final = 2, 10, 1, 0.1, 10000, 500 print('RSMCABC Inferring') journal = sampler.sample([y_obs], steps, n_samples, n_samples_per_param, alpha, epsilon_init, epsilon_final, full_output=1) return journal
def infer_parameters(): # define observation for true parameters mean=170, std=15 y_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.distributions import Uniform prior = Uniform([150, 5],[200, 25], seed=1) # define the model from abcpy.models import Gaussian model = Gaussian(prior, seed=1) # 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.distributions import MultiStudentT mean, cov, df = np.array([.0, .0]), np.eye(2), 3. kernel = MultiStudentT(mean, cov, df, seed=1) # 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(model, distance_calculator, kernel, backend, 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(y_obs, T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
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 test(self): B1 = Binomial([10, 0.2]) N1 = Normal([0.03, 0.01]) N2 = Normal([0.1, N1]) graph1 = Normal([B1, N2]) graph2 = Normal([1, N2]) statistics_calculator = Identity(degree=2, cross=False) distance_calculator = LogReg(statistics_calculator) backend = Backend() sampler = RejectionABC([graph1, graph2], [distance_calculator, distance_calculator], backend) rng = np.random.RandomState(1) sampler.sample_from_prior(rng=rng) mapping, index = sampler._get_mapping() self.assertTrue(mapping == [(B1, 0), (N2, 1), (N1, 2)])
class IdentityTests(unittest.TestCase): def setUp(self): self.stat_calc = Identity(degree=1, cross=0) def test_statistics(self): self.assertRaises(TypeError, self.stat_calc.statistics, 3.4) vec1 = np.array([1, 2]) vec2 = np.array([1]) self.assertTrue( (self.stat_calc.statistics([vec1]) == np.array([vec1])).all()) self.assertTrue( (self.stat_calc.statistics([vec1, vec1]) == np.array([[vec1], [vec1]])).all()) self.assertTrue( (self.stat_calc.statistics([vec2, vec2]) == np.array([[vec2], [vec2]])).all()) def test_polynomial_expansion(self): #Checks whether wrong input type produces error message self.assertRaises(TypeError, self.stat_calc._polynomial_expansion, 3.4) a = [np.array([0, 2]), np.array([2, 1])] # test cross-product part self.stat_calc = Identity(degree=2, cross=1) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4, 0], [2, 1, 4, 1, 2]])).all()) # When a tuple a = [np.array([0, 2])] self.stat_calc = Identity(degree=2, cross=1) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4, 0]])).all()) self.stat_calc = Identity(degree=2, cross=0) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4]])).all()) a = list(np.array([2])) self.stat_calc = Identity(degree=2, cross=1) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[2, 4]])).all())
def infer_parameters_sabc(): # 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 SABC sampler = SABC([height_weight_model], [distance_calculator], backend, seed=1) print('sampling') steps, epsilon, n_samples, n_samples_per_param, beta, delta, v = 2, np.array( [40000]), 10, 1, 2, 0.2, 0.3 ar_cutoff, resample, n_update, adaptcov, full_output = 0.1, None, None, 1, 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, adaptcov, full_output) return journal
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 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)
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 test_polynomial_expansion(self): #Checks whether wrong input type produces error message self.assertRaises(TypeError, self.stat_calc._polynomial_expansion, 3.4) a = [np.array([0, 2]), np.array([2, 1])] # test cross-product part self.stat_calc = Identity(degree=2, cross=1) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4, 0], [2, 1, 4, 1, 2]])).all()) # When a tuple a = [np.array([0, 2])] self.stat_calc = Identity(degree=2, cross=1) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4, 0]])).all()) self.stat_calc = Identity(degree=2, cross=0) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[0, 2, 0, 4]])).all()) a = list(np.array([2])) self.stat_calc = Identity(degree=2, cross=1) self.assertTrue( (self.stat_calc.statistics(a) == np.array([[2, 4]])).all())
def infer_parameters_pmcabc(): # 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 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 journal = sampler.sample([y_obs], T, eps_arr, n_sample, n_samples_per_param, epsilon_percentile) return journal
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 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 mu_shape, sigma_shape = (len(mu_sample), mu_sample[0].shape[1]), \ (len(sigma_sample), sigma_sample[0].shape[1]) self.assertEqual(mu_shape, (10, 1)) self.assertEqual(sigma_shape, (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): # find spark and initialize it self.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 self.model = Gaussian(prior, mu=2.1, sigma=5.0, seed=1) # 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.simulate(1) # define kernel mean = np.array([-13.0, .0, 7.0]) cov = np.eye(3) self.kernel = MultiNormal(mean, cov, seed=1)
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)
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.55548377)), 1e-3) self.assertLess(abs(sigma_post_mean - 5.87147492), 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.88512394)), 1e-3) self.assertLess(abs(sigma_post_mean - 2.90352432), 1e-3) self.assertFalse(journal.number_of_simulations == 0)