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)