def create(self, **kwargs):
models = OrderedDict(kwargs["models"])
states = kwargs["state_lookup_table"]
x_t = pb.RVComp(2, 'x_t')
p = PredictionPdf(models=models, states=states, rv=x_t, cond_rv=pb.RVComp(2, 'x_tp'))
o = ObservationPdf(states=states, models=models, rv=pb.RVComp(2, 'y_t'), cond_rv=[x_t])
# prepare initial particle density:
try:
init_pdf = UniIntPdf(
np.array([0., 0.]),
np.array([float(len(states)-1), float(len(models.keys())-1)]),
cheat=kwargs["ensure_particle_per_state"]
)
except ValueError as e:
print "### [ParticleFilterPredictor] Encountered a problem while creating intial particle distribution:", e
print "### [ParticleFilterPredictor] This might happen if there is only one model or one state defined."
print "### [ParticleFilterPredictor] Currently defined number of states: %s and number of models: %s" % (str(len(states)),str(len(models.keys()))), models.keys()
return None
return {
"filter": ParticleFilter(kwargs["num_particles"], init_pdf, p, o, starvation_factor=1.-kwargs["starvation_factor"]),
"models": models.keys(),
"states": kwargs["state_lookup_table"]
}
def test_init(self):
rvcomp = pb.RVComp(123, "pretty name")
self.assertEquals(rvcomp.name, "pretty name")
self.assertEquals(rvcomp.dimension, 123)
rvcomp = pb.RVComp(345)
self.assertEquals(rvcomp.name, None)
self.assertEquals(rvcomp.dimension, 345)
def _setup_particle_filters(self, n_particles, state_kappa):
"""
Setup the distributions needed by PartcileFilter in pybayes
"""
sys.stdout.flush()
self._n_particles = n_particles
self._state_kappa = state_kappa
ndim = self._get_effective_n_dimensions()
# State RVs
self._x_t = pb.RV(pb.RVComp(ndim, 'x_t'))
self._x_t_1 = pb.RV(pb.RVComp(ndim, 'x_{t-1}'))
# Initial state RV
self._x0 = pb.RV(pb.RVComp(ndim, 'x0'))
init_kappa = .5 # Really small so is almost uniform
init_mu = np.ones((ndim, ))
# Create distributions
self._state_distribution = \
VonMisesCPdf(self._state_kappa, self._x_t, self._x_t_1)
self._init_distribution = \
VonMisesPdf(init_mu, init_kappa, self._x0)
# Do particle filtering ourselves...
self._posterior = EmpPdf(
self._init_distribution.samples(self._n_particles))
self._estimate = self._get_estimate()
self._count = 0
def __init__(self, nr_steps):
print("Generating random data for particle filter stresses A...")
self.nr_steps = nr_steps
# prepare random variable components:
a_t, b_t = pb.RVComp(1, 'a_t'), pb.RVComp(1, 'b_t') # state in t
a_tp, b_tp = pb.RVComp(1,
'a_{t-1}'), pb.RVComp(1,
'b_{t-1}') # state in t-1
# arguments to Kalman filter part of the marginalized particle filter
self.kalman_args = {}
# prepare callback functions
sigma_sq = np.array([0.0001])
def f(cond): # log(b_{t-1}) - 1/2 \sigma^2
return np.log(cond) - sigma_sq / 2.
def g(cond): # \sigma^2
return sigma_sq
# p(a_t | a_{t-1} b_t) density:
p_at_atpbt = pb.LinGaussCPdf(1., 0., 1., 0., [a_t], [a_tp, b_t])
self.kalman_args['A'] = np.array([[1.]]) # process model
# p(b_t | b_{t-1}) density:
self.p_bt_btp = pb.GaussCPdf(1,
1,
f,
g,
rv=[b_t],
cond_rv=[b_tp],
base_class=pb.LogNormPdf)
# p(x_t | x_{t-1}) density:
self.p_xt_xtp = pb.ProdCPdf((p_at_atpbt, self.p_bt_btp), [a_t, b_t],
[a_tp, b_tp])
# prepare p(y_t | x_t) density:
self.p_yt_xt = pb.LinGaussCPdf(1., 0., 1., 0.)
self.kalman_args['C'] = np.array([[1.]]) # observation model
# Initial [a_t, b_t] from .. to:
self.init_range = np.array([[-18., 0.3], [-14., 0.7]])
init_mean = (self.init_range[0] + self.init_range[1]) / 2.
x_t = np.zeros((nr_steps, 2))
x_t[0] = init_mean.copy()
y_t = np.empty((nr_steps, 1))
for i in range(nr_steps):
# set b_t:
x_t[i, 1] = i / 100. + init_mean[1]
# simulate random process:
x_t[i, 0:1] = p_at_atpbt.sample(
x_t[i]) # this is effectively [a_{t-1}, b_t]
y_t[i] = self.p_yt_xt.sample(x_t[i])
# DEBUG: print "simulated x_{0} = {1}".format(i, x_t[i])
# DEBUG: print "simulated y_{0} = {1}".format(i, y_t[i])
self.x_t = x_t
self.y_t = y_t
def _setup_particle_filters(self, n_particles, state_kappa,
observation_kappa, outlier_prob):
"""
Setup the distributions needed by PartcileFilter in pybayes
"""
sys.stdout.flush()
self._n_particles = n_particles
self._state_kappa = state_kappa
self._obs_kappa = observation_kappa
ndim = self._get_effective_n_dimensions()
# State RVs
self._x_t = pb.RV(pb.RVComp(ndim, 'x_t'))
self._x_t_1 = pb.RV(pb.RVComp(ndim, 'x_{t-1}'))
# Observation RV
self._y_t = pb.RV(pb.RVComp(ndim, 'y_t'))
# Initial state RV
self._x0 = pb.RV(pb.RVComp(ndim, 'x0'))
init_kappa = .5 # Really small so is almost uniform
init_mu = np.ones((ndim, ))
# Create distributions
self._state_distribution = \
VonMisesCPdf(self._state_kappa, self._x_t, self._x_t_1)
self._obs_distribution = \
VonMisesCPdf(self._obs_kappa, self._y_t, self._x_t)
self._init_distribution = \
VonMisesPdf(init_mu, init_kappa, self._x0)
# Setup distribution for outliers
if outlier_prob < 0 or outlier_prob > 1:
raise ValueError("Outlier probability must be between 0 and 1")
self._outlier_rv = pb.RV(pb.RVComp(ndim, 'outlier'))
self._outlier_mu = np.hstack((np.array([0, -1.]), np.zeros(
(ndim - 2, ))))
self._outlier_kappa = .001
self._outlier_prob = outlier_prob # Probability of generation from background pdf
self._outlier_distribution = \
VonMisesPdf(self._outlier_mu, self._outlier_kappa, self._outlier_rv)
# Do particle filtering ourselves...
self._posterior = EmpPdf(
self._init_distribution.samples(self._n_particles))
self._estimate = self._get_estimate()
self._count = 0
# Create a set of weights for tracking the distribution p(c_t|x_t,y_{1:t})
self._class_weights = np.array([.5, .5])
# Matrix used to store weights for each particle for each class in order
# to calculate class posterior weights and state posterior weights
self._joint_weights = np.ones((
2,
self._n_particles,
))
def test_rvs(self):
self.assertEqual(self.gauss.rv.dimension, 3)
self.assertEqual(self.gauss.cond_rv.dimension, 0)
a, b = pb.RVComp(2, "a"), pb.RVComp(1, "b")
gauss_rv = pb.GaussPdf(self.mean, self.covariance, pb.RV(a, b))
self.assertTrue(gauss_rv.rv.contains(a))
self.assertTrue(gauss_rv.rv.contains(b))
# invalid total rv dimension:
c = pb.RVComp(2)
self.assertRaises(ValueError, pb.GaussPdf, self.mean, self.covariance,
pb.RV(a, c))
def test_rvs(self):
self.assertEqual(self.gauss.rv.dimension, 1)
self.assertEqual(self.gauss.cond_rv.dimension, 2)
a, b, c = pb.RVComp(1, 'a'), pb.RVComp(1, 'b'), pb.RVComp(1, 'c')
rv = pb.RV(a)
cond_rv = pb.RV(b, c)
gauss = pb.LinGaussCPdf(*self.coeficients, rv=rv, cond_rv=cond_rv)
self.assertTrue(gauss.rv.contains(a))
self.assertFalse(gauss.rv.contains(b))
self.assertFalse(gauss.rv.contains(c))
self.assertFalse(gauss.cond_rv.contains(a))
self.assertTrue(gauss.cond_rv.contains(b))
self.assertTrue(gauss.cond_rv.contains(c))
def test_init(self):
comp_a = pb.RVComp(1, "a")
comp_b = pb.RVComp(2, "b")
rv_1 = pb.RV(comp_a, comp_b)
self.assertEquals(rv_1.name, "[a, b]")
self.assertEquals(rv_1.dimension, 3)
self.assertTrue(rv_1.contains(comp_a))
self.assertTrue(rv_1.contains(comp_b))
rv_2 = pb.RV(rv_1)
self.assertEquals(rv_2.name, "[a, b]")
self.assertEquals(rv_2.dimension, 3)
self.assertTrue(rv_2.contains(comp_a))
self.assertTrue(rv_2.contains(comp_b))
empty_rv = pb.RV()
self.assertEquals(empty_rv.dimension, 0)
self.assertEquals(empty_rv.name, "[]")
def test_rvs(self):
self.assertEqual(self.uni.rv.dimension, 1)
self.assertEqual(self.uni.cond_rv.dimension, 0)
self.assertEqual(self.multiuni.rv.dimension, 3)
self.assertEqual(self.multiuni.cond_rv.dimension, 0)
a = pb.RVComp(2, "a")
b = pb.RVComp(1, "b")
test_uni = pb.UniPdf(np.array([0., -1., 2.]), np.array([1., 1., 4.]),
pb.RV(a, b))
self.assertTrue(test_uni.rv.contains(a))
self.assertTrue(test_uni.rv.contains(b))
test_uni = pb.UniPdf(np.array([0., -1., 2.]), np.array([1., 1., 4.]),
[a, b])
self.assertTrue(test_uni.rv.contains(a))
self.assertTrue(test_uni.rv.contains(b))
def test_rvs(self):
self.assertEqual(self.gauss.rv.dimension, 3)
self.assertEqual(self.gauss.cond_rv.dimension, 2)
a, b, c, d = pb.RVComp(2, 'a'), pb.RVComp(1, 'b'), pb.RVComp(
1, 'c'), pb.RVComp(1, 'd')
rv = pb.RV(a, b)
cond_rv = pb.RV(c, d)
gauss = pb.MLinGaussCPdf(self.covariance, self.A, self.b, rv, cond_rv)
self.assertTrue(gauss.rv.contains(a))
self.assertTrue(gauss.rv.contains(b))
self.assertFalse(gauss.rv.contains(c))
self.assertFalse(gauss.rv.contains(d))
self.assertFalse(gauss.cond_rv.contains(a))
self.assertFalse(gauss.cond_rv.contains(b))
self.assertTrue(gauss.cond_rv.contains(c))
self.assertTrue(gauss.cond_rv.contains(d))
def test_rvs(self):
self.assertEqual(self.prod.rv.dimension, 3)
# test that child rv components are copied into parent ProdPdf
a, b, c = pb.RVComp(1, "a"), pb.RVComp(1, "b"), pb.RVComp(1, "c")
uni = pb.UniPdf(np.array([0., 0.]), np.array([1., 2.]), pb.RV(a, b))
gauss = pb.GaussPdf(np.array([0.]), np.array([[1.]]), pb.RV(c))
prod = pb.ProdPdf((uni, gauss))
self.assertEquals(prod.rv.name, "[a, b, c]")
for rv_comp in a, b, c:
self.assertTrue(prod.rv.contains(rv_comp))
# that that custom rv passed to constructor is accepted
d = pb.RVComp(3, "d")
prod_custom = pb.ProdPdf((uni, gauss), pb.RV(d))
self.assertEquals(prod_custom.rv.name, "[d]")
self.assertTrue(prod_custom.rv.contains(d))
self.assertFalse(prod_custom.rv.contains(a))
self.assertFalse(prod_custom.rv.contains(b))
self.assertFalse(prod_custom.rv.contains(c))
def setUp(self):
self.test_comps = pb.RVComp(1, "a"), pb.RVComp(1, "b"), pb.RVComp(
1, "c"), pb.RVComp(1, "d")
def test_init_with_rvs(self):
x, y = pb.RVComp(1, "result"), pb.RVComp(1, "condition")
self.uni.rv = pb.RV(y)
self.gauss.cond_rv = pb.RV(y)
self.gauss.rv = pb.RV(x)
prod2 = pb.ProdCPdf((self.gauss, self.uni), pb.RV(x, y), pb.RV())
def test_shape_cond_shape(self):
self.cpdf.rv = pb.RV(pb.RVComp(2, "a"))
self.cpdf.cond_rv = pb.RV(pb.RVComp(3, "b"))
self.assertEqual(self.cpdf.shape(), 2)
self.assertEqual(self.cpdf.cond_shape(), 3)
