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 _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_contains_any(self):
a, b, c, d = self.test_comps
rv = pb.RV(a, b, c)
self.assertTrue(rv.contains_any([a, d]))
self.assertTrue(rv.contains_any([b, d]))
self.assertTrue(rv.contains_any([d, c]))
self.assertFalse(rv.contains_any([d]))
def test_contains(self):
a, b, c, d = self.test_comps
rv = pb.RV(b, d)
self.assertFalse(rv.contains(a))
self.assertTrue(rv.contains(b))
self.assertFalse(rv.contains(c))
self.assertTrue(rv.contains(d))
def test_copy(self):
"""Test that shallow copying RV works as expected"""
o = pb.RV(*self.test_comps)
c = copy(o)
self.assertTrue(id(o) != id(c))
self.assertTrue(id(o.name) == id(c.name))
self.assertTrue(id(o.dimension) == id(c.dimension))
self.assertTrue(id(o.components) == id(c.components))
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.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_contains_all(self):
a, b, c, d = self.test_comps
rv = pb.RV(a, b, c)
self.assertTrue(rv.contains_all([a, b]))
self.assertTrue(rv.contains_all([c, b]))
self.assertTrue(rv.contains_all([b, a, c]))
self.assertFalse(rv.contains_all([b, c, d]))
self.assertFalse(rv.contains_all([d]))
self.assertFalse(rv.contains_all([a, b, c, 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 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_deepcopy(self):
"""Test that deep copying RV works as expected"""
o = pb.RV(*self.test_comps)
c = deepcopy(o)
self.assertRVsEqualNotSame(o, c)
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)