class LogRegTests(unittest.TestCase):
def setUp(self):
self.stat_calc = Identity(degree=2, cross=False)
self.distancefunc = LogReg(self.stat_calc, seed=1)
self.rng = np.random.RandomState(1)
def test_distance(self):
d1 = 0.5 * self.rng.randn(100, 2) - 10
d2 = 0.5 * self.rng.randn(100, 2) + 10
d1 = d1.tolist()
d2 = d2.tolist()
# Checks whether wrong input type produces error message
self.assertRaises(TypeError, self.distancefunc.distance, 3.4, d2)
self.assertRaises(TypeError, self.distancefunc.distance, d1, 3.4)
# completely separable datasets should have a distance of 1.0
self.assertEqual(self.distancefunc.distance(d1, d2), 1.0)
# equal data sets should have a distance of 0.0
self.assertEqual(self.distancefunc.distance(d1, d1), 0.0)
def test_dist_max(self):
self.assertTrue(self.distancefunc.dist_max() == 1.0)
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])
# define the model
model = Gaussian(prior)
# 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)
# define backend
from abcpy.backends import BackendDummy as Backend
backend = Backend()
# define sampling scheme
from abcpy.inferences import PMCABC
sampler = PMCABC(model, distance_calculator, kernel, backend)
# 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):
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 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)
y_sim = sampler.simulate(1, rng=rng)
self.assertTrue(isinstance(y_sim, list))
self.assertTrue(len(y_sim) == 2)
self.assertTrue(isinstance(y_sim[0][0], np.ndarray))
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 = PMCABC([self.graph], [distance_calculator], backend)
self.rng = np.random.RandomState(1)
self.sampler.sample_from_prior(rng=self.rng)
kernel = DefaultKernel([self.N1, self.N2, self.B1])
self.sampler.kernel = kernel
self.sampler.accepted_parameters_manager.update_broadcast(
self.sampler.backend, [[3, 0.11, 0.029], [4, 0.098, 0.031]],
accepted_cov_mats=[[[1, 0], [0, 1]]],
accepted_weights=np.array([1, 1]))
kernel_parameters = []
for kernel in self.sampler.kernel.kernels:
kernel_parameters.append(
self.sampler.accepted_parameters_manager.
get_accepted_parameters_bds_values(kernel.models))
self.sampler.accepted_parameters_manager.update_kernel_values(
self.sampler.backend, kernel_parameters)
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
class LogRegTests(unittest.TestCase):
def setUp(self):
self.stat_calc = Identity(degree = 1, cross = 0)
self.distancefunc = LogReg(self.stat_calc)
def test_distance(self):
d1 = 0.5 * np.random.randn(100,2) - 10
d2 = 0.5 * np.random.randn(100,2) + 10
#Checks whether wrong input type produces error message
self.assertRaises(TypeError, self.distancefunc.distance, 3.4, d2)
self.assertRaises(TypeError, self.distancefunc.distance, d1, 3.4)
# completely separable datasets should have a distance of 1.0
self.assertEqual(self.distancefunc.distance(list(d1),list(d2)), 1.0)
# equal data sets should have a distance of 0.0
self.assertEqual(self.distancefunc.distance(list(d1),list(d1)), 0.0)
def test_dist_max(self):
self.assertTrue(self.distancefunc.dist_max() == 1.0)
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 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 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 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)])
def infer_parameters():
# define backend
# Note, the dummy backend does not parallelize the code!
from abcpy.backends import BackendDummy as Backend
backend = Backend()
# 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
height = Normal([mu, sigma], )
# define statistics
from abcpy.statistics import Identity
statistics_calculator = Identity(degree=3, cross=True)
# Learn the optimal summary statistics using Semiautomatic summary selection
from abcpy.summaryselections import Semiautomatic
summary_selection = Semiautomatic([height],
statistics_calculator,
backend,
n_samples=1000,
n_samples_per_param=1,
seed=1)
# Redefine the statistics function
statistics_calculator.statistics = lambda x, f2=summary_selection.transformation, \
f1=statistics_calculator.statistics: f2(f1(x))
# define distance
from abcpy.distances import LogReg
distance_calculator = LogReg(statistics_calculator)
# define kernel
from abcpy.perturbationkernel import DefaultKernel
kernel = DefaultKernel([mu, sigma])
# 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(steps=3,
n_sample=250,
n_samples_per_param=10,
logging_level=logging.WARN):
"""Perform inference for this example.
Parameters
----------
steps : integer, optional
Number of iterations in the sequential PMCABC algoritm ("generations"). The default value is 3
n_samples : integer, optional
Number of posterior samples to generate. The default value is 250.
n_samples_per_param : integer, optional
Number of data points in each simulated data set. The default value is 10.
Returns
-------
abcpy.output.Journal
A journal containing simulation results, metadata and optionally intermediate results.
"""
logging.basicConfig(level=logging_level)
# 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.continuousmodels import Uniform
mu = Uniform([[150], [200]], name="mu")
sigma = Uniform([[5], [25]], name="sigma")
# define the model
model = 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, seed=42)
# define backend
from abcpy.backends import BackendDummy as Backend
backend = Backend()
# define sampling scheme
from abcpy.inferences import PMCABC
sampler = PMCABC([model], [distance_calculator], backend, seed=1)
# sample from scheme
eps_arr = np.array([.75])
epsilon_percentile = 10
journal = sampler.sample([y_obs], steps, eps_arr, n_sample,
n_samples_per_param, epsilon_percentile)
return journal
def setUp(self):
self.stat_calc = Identity(degree=1, cross=0)
self.distancefunc = LogReg(self.stat_calc)
rng = np.random.RandomState(rseed)
n_samples = int(T / dt) + 1
noise = rng.normal(loc=0, scale=0.05, size=(n_samples))
obs_data = hh_simulator.forward_simulate([gbar_K_true, gbar_Na_true])
# define statistics
# statistics_calculator = Identity()
t = stimulus_dict["t"]
stim_duration = stimulus_dict["duration"]
t_stim_on = stimulus_dict["t_stim_on"]
statistics_calculator = Features(t, stim_duration, t_stim_on)
# define distance
distance_calculator = Euclidean(statistics_calculator)
distance_calculator2 = Wasserstein(statistics_calculator)
distance_calculator3 = LogReg(statistics_calculator)
# checking
sim_data = hh_simulator.forward_simulate(
[gbar_K_true + 3, gbar_Na_true + 4])
#obs_data = [obs_data[0] / np.max(obs_data[0]) + noise]
#sim_data = [sim_data[0] / np.max(sim_data[0])]
s1 = statistics_calculator.statistics(obs_data)
s2 = statistics_calculator.statistics(sim_data)
dist = distance_calculator.distance(obs_data, sim_data)
dist2 = distance_calculator2.distance(obs_data, sim_data)
dist3 = distance_calculator3.distance(obs_data, sim_data)
print(s1)
print(s2)
def setUp(self):
self.stat_calc = Identity(degree=2, cross=False)
self.distancefunc = LogReg(self.stat_calc, seed=1)
self.rng = np.random.RandomState(1)
