def test_divergence(self):
rv1d = rv_discrete([(0, ), (1, ), (2, )], pk=[0.3, 0.3, 0.4])
rv2d = rv_discrete([(0, ), (1, ), (4, )], pk=[0.2, 0.4, 0.4])
c1 = [(-2, 2), (1, 5)]
c2 = [(-1, 4), (-3, 3)]
# c_target = [(-1,2),(1,3)]
rv1c = rv_continuous(KernelDensity().fit([[-1, 2]]), (2, ), c1)
rv2c = rv_continuous(KernelDensity().fit([[1, 3]]), (2, ), c2)
# the data makes no sense, this is just a pro forma test
rv1 = rv_mixed(
rv1c, rv1d, {
(0, ): KernelDensity().fit([[-1, 2]]),
(1, ): KernelDensity().fit([[-2, 3], [-1, 4]])
})
rv2 = rv_mixed(
rv2c, rv2d, {
(0, ): KernelDensity().fit([[-1, 2]]),
(1, ): KernelDensity().fit([[-3, 4], [0, 0]])
})
divergence = rv1.divergence(rv2)
self.assertEqual(type(divergence), np.float64)
self.assertGreater(divergence, 0.0)
def test_divergence(self):
rv1 = rv_discrete([(0, ), (1, ), (2, )], pk=[0.3, 0.3, 0.4])
rv2 = rv_discrete([(0, ), (1, ), (4, )], pk=[0.2, 0.4, 0.4])
pd_1 = rv1.score_samples([(0, ), (1, )])
pd_2 = rv2.score_samples([(0, ), (1, )])
divergence_target = rv1.divergence_from_distribution(pd_1, pd_2)
divergence_is = rv1.divergence(rv2)
self.assertEqual(divergence_is, divergence_target)
def test_common_coverage(self):
rv1 = rv_discrete([(0, ), (1, ), (2, )], pk=[0.3, 0.3, 0.4])
rv2 = rv_discrete([(0, ), (1, ), (4, )], pk=[0.2, 0.4, 0.4])
coverage_is = rv1._common_coverage(rv2)
coverage_reverse = rv2._common_coverage(rv1)
coverage_target = np.array([(0, ), (1, )]).reshape(-1)
self.assertTrue(
np.array_equal(coverage_is, coverage_target),
f"covarage_is {coverage_is} not equal to coverage_target {coverage_target}."
)
self.assertTrue(
np.array_equal(coverage_is, coverage_reverse),
f"covarage_is {coverage_is} not equal to coverage_target {coverage_reverse}."
)
def test_common_coverage(self):
rv1d = rv_discrete([(0, ), (1, ), (2, )], pk=[0.3, 0.3, 0.4])
rv2d = rv_discrete([(0, ), (1, ), (4, )], pk=[0.2, 0.4, 0.4])
c1 = [(-2, 2), (1, 5)]
c2 = [(-1, 4), (-3, 3)]
rv1c = rv_continuous(KernelDensity().fit([[0, 1]]), (2, ), c1)
rv2c = rv_continuous(KernelDensity().fit([[0, 1]]), (2, ), c2)
rv1 = rv_mixed(rv1c, rv1d, {(0, ): KernelDensity().fit([[1, 1]])})
rv2 = rv_mixed(rv2c, rv2d, {(0, ): KernelDensity().fit([[1, 0]])})
y_target = np.repeat([0, 1], 1000)
x, y = rv1._common_coverage(rv2, 1000)
self.assertEqual(x.shape[0], 2000)
self.assertEqual(x.shape[1], 2)
self.assertEqual(y.shape[0], x.shape[0])
self.assertTrue(np.array_equal(y, y_target),
f"y {y} is not equal y_target {y_target}.")
def test_score_samples(self):
xk = [(0, ), (1, )]
pk = [0.6, 0.4]
rv = rv_discrete(xk, pk, badvalue=0)
x = [0, 0, 1, 1, 2]
score_is = rv.score_samples(x)
score_target = np.log(np.array([0.6, 0.6, 0.4, 0.4, 0]))
self.assertTrue(np.array_equal(score_is, score_target),
f"P_is: {score_is} is not P_target: {score_target}.")
def test_pmf_scalar(self):
xk = [(0, ), (1, )]
pk = [0.6, 0.4]
rv = rv_discrete(xk, pk, badvalue=0)
x = [0, 0, 1, 1, 2]
P_is = rv.pmf(x)
P_target = np.array([0.6, 0.6, 0.4, 0.4, 0])
self.assertTrue(np.array_equal(P_is, P_target),
f"P_is: {P_is} is not P_target: {P_target}.")
def test_get_cond_kdes_wrong_key(self):
rv_x = rv_continuous(self.kde, (2, ))
rv_y = rv_discrete(xk=[(0, ), (1, )], pk=[.5, .5])
cond_kdes = {
(0, ): KernelDensity(bandwidth=1.0),
(1, ): KernelDensity(bandwidth=99.0)
}
rv = rv_mixed(rv_x, rv_y, cond_kdes)
with self.assertRaises(KeyError):
kde_is = rv._get_cond_kde(3)
def test_get_cond_kdes_from_tuple(self):
rv_x = rv_continuous(self.kde, (2, ))
rv_y = rv_discrete(xk=[(0, 0), (1, 0)], pk=[.5, .5])
cond_kdes = {
(0, 0): KernelDensity(bandwidth=1.0),
(1, 0): KernelDensity(bandwidth=99.0)
}
rv = rv_mixed(rv_x, rv_y, cond_kdes)
kde_is = rv._get_cond_kde((0, 0))
kde_target = cond_kdes[(0, 0)]
self.assertEqual(kde_is, kde_target)
def test_pdf_for_1d_discrete(self):
rv_x = rv_continuous(self.kde, (2, ))
rv_y = rv_discrete(xk=[(0, ), (1, )], pk=[.5, .5])
cond_kdes = {(0, ): self.kde0, (1, ): self.kde1}
rv = rv_mixed(rv_x, rv_y, cond_kdes)
P_is = rv.pdf(x=[[0, 0], [0, 0]], y=[1, 0])
P_target = [self.p_00 * 0.5, self.p_00 * 0.5]
is_close = np.isclose(P_is, P_target, rtol=0.2)
self.assertTrue(
is_close.all(),
f"P_is: {P_is} is not close enough to P_target: {P_target}. ")
def test_prob_of_invalid(self):
xk = [(0, ), (1, )]
pk = [0.6, 0.4]
rv = rv_discrete(xk, pk)
p = rv._prob_of(3)
self.assertIs(p, rv.badvalue)
def test_prob_of_list(self):
xk = [(0, ), (1, )]
pk = [0.6, 0.4]
rv = rv_discrete(xk, pk)
p = rv._prob_of([0])
self.assertIs(p, 0.6)
def test_prob_of_scalar(self):
xk = [(0, ), (1, )]
pk = [0.6, 0.4]
rv = rv_discrete(xk, pk)
p = rv._prob_of(0)
self.assertEqual(p, 0.6)
def test_prob_of_tuple(self):
xk = [(0, 1), (1, 0)]
pk = [0.6, 0.4]
rv = rv_discrete(xk, pk)
p = rv._prob_of((0, 1))
self.assertEqual(p, 0.6)
def test_xk_and_pk_dimensions(self):
xk = [(0, 1), (1, 0), (1, 1)]
pk = [0.6, 0.4]
with self.assertRaises(ValueError):
rv = rv_discrete(xk, pk)
