def test_logl_dbn(): variables = ["a", "b", "c", "d"] static_bn = GaussianNetwork(["a", "b", "c", "d"], [("a", "c"), ("b", "c"), ("c", "d")]) static_bn = GaussianNetwork(["a", "b", "c", "d"], [("a", "c"), ("b", "c"), ("c", "d")]) gbn = DynamicGaussianNetwork(variables, 2) static_bn = gbn.static_bn() static_bn.add_arc("a_t_2", "c_t_2") static_bn.add_arc("b_t_2", "c_t_2") static_bn.add_arc("c_t_2", "d_t_2") static_bn.add_arc("a_t_1", "c_t_1") static_bn.add_arc("b_t_1", "c_t_1") static_bn.add_arc("c_t_1", "d_t_1") transition_bn = gbn.transition_bn() transition_bn.add_arc("a_t_2", "a_t_0") transition_bn.add_arc("b_t_2", "b_t_0") transition_bn.add_arc("c_t_2", "c_t_0") transition_bn.add_arc("d_t_2", "d_t_0") transition_bn.add_arc("a_t_1", "a_t_0") transition_bn.add_arc("b_t_1", "b_t_0") transition_bn.add_arc("c_t_1", "c_t_0") transition_bn.add_arc("d_t_1", "d_t_0") gbn.fit(df) test_df = util_test.generate_normal_data(100) ground_truth_ll = numpy_logl(gbn, util_test.generate_normal_data(100)) ll = gbn.logl(test_df) assert np.all(np.isclose(ground_truth_ll, ll))
def test_kde_slogl_null(): def _test_kde_slogl_null_iter(variables, _df, _test_df): cpd = pbn.KDE(variables) cpd.fit(_df) npdata = _df.loc[:, variables].to_numpy() scipy_kde = gaussian_kde( npdata.T, bw_method=lambda s: np.power(4 / (s.d + 2), 1 / (s.d + 4)) * s.scotts_factor()) test_npdata = _test_df.loc[:, variables].to_numpy() assert np.all( np.isclose(cpd.slogl(_test_df), np.nansum(scipy_kde.logpdf(test_npdata.T)))) TEST_SIZE = 50 test_df = util_test.generate_normal_data(TEST_SIZE, seed=1) test_df_float = test_df.astype('float32') np.random.seed(0) a_null = np.random.randint(0, TEST_SIZE, size=10) b_null = np.random.randint(0, TEST_SIZE, size=10) c_null = np.random.randint(0, TEST_SIZE, size=10) d_null = np.random.randint(0, TEST_SIZE, size=10) df_null = test_df.copy() df_null.loc[df_null.index[a_null], 'a'] = np.nan df_null.loc[df_null.index[b_null], 'b'] = np.nan df_null.loc[df_null.index[c_null], 'c'] = np.nan df_null.loc[df_null.index[d_null], 'd'] = np.nan df_null_float = test_df_float.copy() df_null_float.loc[df_null_float.index[a_null], 'a'] = np.nan df_null_float.loc[df_null_float.index[b_null], 'b'] = np.nan df_null_float.loc[df_null_float.index[c_null], 'c'] = np.nan df_null_float.loc[df_null_float.index[d_null], 'd'] = np.nan for variables in [['a'], ['b', 'a'], ['c', 'a', 'b'], ['d', 'a', 'b', 'c']]: _test_kde_slogl_null_iter(variables, df, df_null) _test_kde_slogl_null_iter(variables, df_float, df_null_float) cpd = pbn.KDE(['d', 'a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.KDE(['a', 'c', 'd', 'b']) cpd2.fit(df) assert np.all(np.isclose( cpd.slogl(df_null), cpd2.slogl(df_null))), "Order of evidence changes slogl() result." cpd = pbn.KDE(['d', 'a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.KDE(['a', 'c', 'd', 'b']) cpd2.fit(df_float) assert np.all( np.isclose(cpd.slogl(df_null_float), cpd2.slogl( df_null_float))), "Order of evidence changes slogl() result."
def test_productkde_slogl(): def _test_productkde_slogl_iter(variables, _df, _test_df): cpd = pbn.ProductKDE(variables) cpd.fit(_df) npdata = _df.loc[:, variables].to_numpy() final_scipy_kde = gaussian_kde(npdata.T) final_scipy_kde.covariance = np.diag(cpd.bandwidth) final_scipy_kde.inv_cov = np.diag(1. / cpd.bandwidth) final_scipy_kde.log_det = cpd.bandwidth.shape[0] * np.log(2*np.pi) + np.log(cpd.bandwidth).sum() test_npdata = _test_df.loc[:, variables].to_numpy() assert np.all(np.isclose(cpd.slogl(_test_df), final_scipy_kde.logpdf(test_npdata.T).sum())) test_df = util_test.generate_normal_data(50, seed=1) test_df_float = test_df.astype('float32') for variables in [['a'], ['b', 'a'], ['c', 'a', 'b'], ['d', 'a', 'b', 'c']]: _test_productkde_slogl_iter(variables, df, test_df) _test_productkde_slogl_iter(variables, df_float, test_df_float) cpd = pbn.ProductKDE(['d', 'a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.ProductKDE(['a', 'c', 'd', 'b']) cpd2.fit(df) assert np.all(np.isclose(cpd.slogl(test_df), cpd2.slogl(test_df))), "Order of evidence changes slogl() result." cpd = pbn.ProductKDE(['d', 'a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.ProductKDE(['a', 'c', 'd', 'b']) cpd2.fit(df_float) assert np.all(np.isclose(cpd.slogl(test_df_float), cpd2.slogl(test_df_float), atol=0.0005)), "Order of evidence changes slogl() result."
def test_lg_slogl_null(): test_df = util_test.generate_normal_data(5000) np.random.seed(0) a_null = np.random.randint(0, 5000, size=100) b_null = np.random.randint(0, 5000, size=100) c_null = np.random.randint(0, 5000, size=100) d_null = np.random.randint(0, 5000, size=100) df_null = test_df.copy() df_null.loc[df_null.index[a_null], 'a'] = np.nan df_null.loc[df_null.index[b_null], 'b'] = np.nan df_null.loc[df_null.index[c_null], 'c'] = np.nan df_null.loc[df_null.index[d_null], 'd'] = np.nan for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: cpd = pbn.LinearGaussianCPD(variable, evidence) cpd.fit(df) beta = cpd.beta variance = cpd.variance assert np.all(np.isclose(cpd.slogl(df_null), np.nansum(numpy_logpdf(df_null, variable, evidence, beta, variance)))),\ "Wrong slogl for LinearGaussianCPD(" + str(variable) + " | " + str(evidence) + ") with null values." cpd = pbn.LinearGaussianCPD('d', ['a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.LinearGaussianCPD('d', ['c', 'a', 'b']) cpd2.fit(df) assert np.all(np.isclose(cpd.slogl(df_null), cpd2.slogl(df_null))), "The order of the evidence changes the slogl() result."
def test_productkde_logl_null(): def _test_productkde_logl_null_iter(variables, _df, _test_df): cpd = pbn.ProductKDE(variables) cpd.fit(_df) logl = cpd.logl(_test_df) npdata = _df.loc[:, variables].to_numpy() final_scipy_kde = gaussian_kde(npdata.T) final_scipy_kde.covariance = np.diag(cpd.bandwidth) final_scipy_kde.inv_cov = np.diag(1. / cpd.bandwidth) final_scipy_kde.log_det = cpd.bandwidth.shape[0] * np.log(2*np.pi) + np.log(cpd.bandwidth).sum() test_npdata = _test_df.loc[:, variables].to_numpy() scipy = final_scipy_kde.logpdf(test_npdata.T) if npdata.dtype == "float32": assert np.all(np.isclose(logl, scipy, atol=0.0005, equal_nan=True)) else: assert np.all(np.isclose(logl, scipy, equal_nan=True)) TEST_SIZE = 50 test_df = util_test.generate_normal_data(TEST_SIZE, seed=1) test_df_float = test_df.astype('float32') np.random.seed(0) a_null = np.random.randint(0, TEST_SIZE, size=10) b_null = np.random.randint(0, TEST_SIZE, size=10) c_null = np.random.randint(0, TEST_SIZE, size=10) d_null = np.random.randint(0, TEST_SIZE, size=10) df_null = test_df.copy() df_null.loc[df_null.index[a_null], 'a'] = np.nan df_null.loc[df_null.index[b_null], 'b'] = np.nan df_null.loc[df_null.index[c_null], 'c'] = np.nan df_null.loc[df_null.index[d_null], 'd'] = np.nan df_null_float = test_df_float.copy() df_null_float.loc[df_null_float.index[a_null], 'a'] = np.nan df_null_float.loc[df_null_float.index[b_null], 'b'] = np.nan df_null_float.loc[df_null_float.index[c_null], 'c'] = np.nan df_null_float.loc[df_null_float.index[d_null], 'd'] = np.nan for variables in [['a'], ['b', 'a'], ['c', 'a', 'b'], ['d', 'a', 'b', 'c']]: _test_productkde_logl_null_iter(variables, df, df_null) _test_productkde_logl_null_iter(variables, df_float, df_null_float) cpd = pbn.ProductKDE(['d', 'a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.ProductKDE(['a', 'c', 'd', 'b']) cpd2.fit(df) assert np.all(np.isclose(cpd.logl(df_null), cpd2.logl(df_null), equal_nan=True)), "Order of evidence changes logl() result." cpd = pbn.ProductKDE(['d', 'a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.ProductKDE(['a', 'c', 'd', 'b']) cpd2.fit(df_float) assert np.all(np.isclose(cpd.logl(df_null_float), cpd2.logl(df_null_float), atol=0.0005, equal_nan=True)), "Order of evidence changes logl() result."
def test_kde_logl(): def _test_kde_logl_iter(variables, _df, _test_df): cpd = pbn.KDE(variables) cpd.fit(_df) npdata = _df.loc[:, variables].to_numpy() scipy_kde = gaussian_kde( npdata.T, bw_method=lambda s: np.power(4 / (s.d + 2), 1 / (s.d + 4)) * s.scotts_factor()) test_npdata = _test_df.loc[:, variables].to_numpy() logl = cpd.logl(_test_df) scipy = scipy_kde.logpdf(test_npdata.T) if np.all(_df.dtypes == 'float32'): assert np.all(np.isclose(logl, scipy, atol=0.0005)) else: assert np.all(np.isclose(logl, scipy)) test_df = util_test.generate_normal_data(50, seed=1) test_df_float = test_df.astype('float32') for variables in [['a'], ['b', 'a'], ['c', 'a', 'b'], ['d', 'a', 'b', 'c']]: _test_kde_logl_iter(variables, df, test_df) _test_kde_logl_iter(variables, df_float, test_df_float) cpd = pbn.KDE(['d', 'a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.KDE(['a', 'c', 'd', 'b']) cpd2.fit(df) assert np.all(np.isclose( cpd.logl(test_df), cpd2.logl(test_df))), "Order of evidence changes logl() result." cpd = pbn.KDE(['d', 'a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.KDE(['a', 'c', 'd', 'b']) cpd2.fit(df_float) assert np.all(np.isclose( cpd.logl(test_df_float), cpd2.logl(test_df_float))), "Order of evidence changes logl() result."
def test_ckde_slogl(): def _test_ckde_slogl(variable, evidence, _df, _test_df): cpd = pbn.CKDE(variable, evidence) cpd.fit(_df) scipy_kde_joint, scipy_kde_marg = train_scipy_ckde( _df, variable, evidence) scipy_logl = scipy_ckde_logpdf(_test_df, scipy_kde_joint, scipy_kde_marg, variable, evidence) if np.all(_test_df.dtypes == "float32"): # Allow an error of 0.0005 for each training instance. assert np.isclose(cpd.slogl(_test_df), scipy_logl.sum(), atol=0.0005 * _df.shape[0]) else: assert np.isclose(cpd.slogl(_test_df), scipy_logl.sum()) test_df = util_test.generate_normal_data(TEST_SIZE, seed=1) test_df_float = test_df.astype('float32') for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: _test_ckde_slogl(variable, evidence, df, test_df) _test_ckde_slogl(variable, evidence, df_small, test_df) _test_ckde_slogl(variable, evidence, df_float, test_df_float) _test_ckde_slogl(variable, evidence, df_small_float, test_df_float) cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df) assert np.all(np.isclose( cpd.slogl(test_df), cpd2.slogl(test_df))), "Order of evidence changes slogl() result." cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df_float) assert np.all( np.isclose(cpd.slogl(test_df_float), cpd2.slogl( test_df_float))), "Order of evidence changes slogl() result."
def test_lg_slogl(): test_df = util_test.generate_normal_data(5000) for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: cpd = pbn.LinearGaussianCPD(variable, evidence) cpd.fit(df) beta = cpd.beta variance = cpd.variance assert np.all(np.isclose(cpd.slogl(test_df), np.sum(numpy_logpdf(test_df, variable, evidence, beta, variance)))),\ "Wrong slogl for LinearGaussianCPD(" + str(variable) + " | " + str(evidence) + ")" cpd = pbn.LinearGaussianCPD('d', ['a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.LinearGaussianCPD('d', ['c', 'a', 'b']) cpd2.fit(df) assert np.all(np.isclose(cpd.slogl(test_df), cpd2.slogl(test_df))), "The order of the evidence changes the slogl() result."
def test_ckde_cdf(): def _test_ckde_cdf(variable, evidence, _df, _test_df): cpd = pbn.CKDE(variable, evidence) cpd.fit(_df) scipy_kde_joint, scipy_kde_marg = train_scipy_ckde( _df, variable, evidence) cdf = cpd.cdf(_test_df) scipy = scipy_ckde_cdf(_test_df, scipy_kde_joint, scipy_kde_marg, variable, evidence) if np.all(_df.dtypes == 'float32'): assert np.all(np.isclose(cdf, scipy, atol=0.0005)) else: assert np.all(np.isclose(cdf, scipy)) test_df = util_test.generate_normal_data(TEST_SIZE, seed=1) test_df_float = test_df.astype('float32') for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: _test_ckde_cdf(variable, evidence, df, test_df) _test_ckde_cdf(variable, evidence, df_small, test_df) _test_ckde_cdf(variable, evidence, df_float, test_df_float) _test_ckde_cdf(variable, evidence, df_small_float, test_df_float) cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df) assert np.all(np.isclose( cpd.cdf(test_df), cpd2.cdf(test_df))), "Order of evidence changes logl() result." cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df_float) assert np.all( np.isclose(cpd.cdf(test_df_float), cpd2.cdf(test_df_float), atol=0.0005)), "Order of evidence changes logl() result."
def test_logl(): spbn = SemiparametricBN([('a', 'b'), ('a', 'c'), ('a', 'd'), ('b', 'c'), ('b', 'd'), ('c', 'd')]) spbn.fit(df) test_df = util_test.generate_normal_data(5000) ll = spbn.logl(test_df) sll = spbn.slogl(test_df) sum_ll = np.zeros((5000, )) sum_sll = 0 for n in spbn.nodes(): cpd = spbn.cpd(n) l = cpd.logl(test_df) s = cpd.slogl(test_df) assert np.all(np.isclose(s, l.sum())) sum_ll += l sum_sll += s assert np.all(np.isclose(ll, sum_ll)) assert np.isclose(sll, ll.sum()) assert sll == sum_sll
import pytest import numpy as np import pybnesian as pbn import util_test SIZE = 10000 df = util_test.generate_normal_data(SIZE) def test_create_change_node(): gbn = pbn.GaussianNetwork(['a', 'b', 'c', 'd']) cv = pbn.CVLikelihood(df) node_op = pbn.ChangeNodeTypeSet() with pytest.raises(ValueError) as ex: node_op.cache_scores(gbn, cv) assert "can only be used with non-homogeneous" in str(ex.value) def test_lists(): gbn = pbn.GaussianNetwork(['a', 'b', 'c', 'd']) bic = pbn.BIC(df) arc_op = pbn.ArcOperatorSet() arc_op.set_arc_blacklist([("b", "a")]) arc_op.set_arc_whitelist([("b", "c")]) arc_op.set_max_indegree(3) arc_op.set_type_whitelist([("a", pbn.LinearGaussianCPDType())])
import numpy as np import pybnesian as pbn from pybnesian import BayesianNetworkType, BayesianNetwork import util_test df = util_test.generate_normal_data(1000) def test_hc_estimate(): bic = pbn.BIC(df) column_names = list(df.columns.values) start = pbn.GaussianNetwork(column_names) # Check algorithm with BN with nodes removed. column_names.insert(1, 'e') column_names.insert(3, 'f') start_removed_nodes = pbn.GaussianNetwork(column_names) start_removed_nodes.remove_node('e') start_removed_nodes.remove_node('f') arc_set = pbn.ArcOperatorSet() hc = pbn.GreedyHillClimbing() res = hc.estimate(arc_set, bic, start, max_iters=1) assert res.num_arcs() == 1 added_arc = res.arcs()[0] op_delta = bic.score(res) - bic.score(start) res_removed = hc.estimate(arc_set, bic, start_removed_nodes, max_iters=1) assert res.num_arcs() == 1
def test_ckde_cdf_null(): def _test_ckde_cdf_null(variable, evidence, _df, _test_df): cpd = pbn.CKDE(variable, evidence) cpd.fit(_df) scipy_kde_joint, scipy_kde_marg = train_scipy_ckde( _df, variable, evidence) cdf = cpd.cdf(_test_df) scipy = scipy_ckde_cdf(_test_df, scipy_kde_joint, scipy_kde_marg, variable, evidence) if np.all(_df.dtypes == 'float32'): assert np.all(np.isclose(cdf, scipy, atol=0.0005, equal_nan=True)) else: assert np.all(np.isclose(cdf, scipy, equal_nan=True)) test_df = util_test.generate_normal_data(TEST_SIZE, seed=1) test_df_float = test_df.astype('float32') np.random.seed(0) a_null = np.random.randint(0, TEST_SIZE, size=10) b_null = np.random.randint(0, TEST_SIZE, size=10) c_null = np.random.randint(0, TEST_SIZE, size=10) d_null = np.random.randint(0, TEST_SIZE, size=10) df_null = test_df.copy() df_null.loc[df_null.index[a_null], 'a'] = np.nan df_null.loc[df_null.index[b_null], 'b'] = np.nan df_null.loc[df_null.index[c_null], 'c'] = np.nan df_null.loc[df_null.index[d_null], 'd'] = np.nan df_null_float = test_df_float.copy() df_null_float.loc[df_null_float.index[a_null], 'a'] = np.nan df_null_float.loc[df_null_float.index[b_null], 'b'] = np.nan df_null_float.loc[df_null_float.index[c_null], 'c'] = np.nan df_null_float.loc[df_null_float.index[d_null], 'd'] = np.nan for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: _test_ckde_cdf_null(variable, evidence, df, df_null) _test_ckde_cdf_null(variable, evidence, df_small, df_null) _test_ckde_cdf_null(variable, evidence, df_float, df_null_float) _test_ckde_cdf_null(variable, evidence, df_small_float, df_null_float) cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df) assert np.all( np.isclose(cpd.cdf(df_null), cpd2.cdf(df_null), equal_nan=True)), "Order of evidence changes cdf() result." cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df_float) assert np.all( np.isclose(cpd.cdf(df_null_float), cpd2.cdf(df_null_float), atol=0.0005, equal_nan=True)), "Order of evidence changes cdf() result."
def test_ckde_slogl_null(): def _test_ckde_slogl_null(variable, evidence, _df, _test_df): cpd = pbn.CKDE(variable, evidence) cpd.fit(_df) scipy_kde_joint, scipy_kde_marg = train_scipy_ckde( _df, variable, evidence) scipy_logl = scipy_ckde_logpdf(_test_df, scipy_kde_joint, scipy_kde_marg, variable, evidence) if np.all(_test_df.dtypes == "float32"): # Allow an error of 0.0005 for each training instance. assert np.isclose(cpd.slogl(_test_df), np.nansum(scipy_logl), atol=0.0005 * _df.shape[0]) else: assert np.isclose(cpd.slogl(_test_df), np.nansum(scipy_logl)) test_df = util_test.generate_normal_data(TEST_SIZE, seed=1) test_df_float = test_df.astype('float32') np.random.seed(0) a_null = np.random.randint(0, TEST_SIZE, size=10) b_null = np.random.randint(0, TEST_SIZE, size=10) c_null = np.random.randint(0, TEST_SIZE, size=10) d_null = np.random.randint(0, TEST_SIZE, size=10) df_null = test_df.copy() df_null.loc[df_null.index[a_null], 'a'] = np.nan df_null.loc[df_null.index[b_null], 'b'] = np.nan df_null.loc[df_null.index[c_null], 'c'] = np.nan df_null.loc[df_null.index[d_null], 'd'] = np.nan df_null_float = test_df_float.copy() df_null_float.loc[df_null_float.index[a_null], 'a'] = np.nan df_null_float.loc[df_null_float.index[b_null], 'b'] = np.nan df_null_float.loc[df_null_float.index[c_null], 'c'] = np.nan df_null_float.loc[df_null_float.index[d_null], 'd'] = np.nan for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: _test_ckde_slogl_null(variable, evidence, df, df_null) _test_ckde_slogl_null(variable, evidence, df_small, df_null) _test_ckde_slogl_null(variable, evidence, df_float, df_null_float) _test_ckde_slogl_null(variable, evidence, df_small_float, df_null_float) cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df) assert np.all(np.isclose( cpd.slogl(df_null), cpd2.slogl(df_null))), "Order of evidence changes slogl() result." cpd = pbn.CKDE('d', ['a', 'b', 'c']) cpd.fit(df_float) cpd2 = pbn.CKDE('d', ['c', 'b', 'a']) cpd2.fit(df_float) assert np.all( np.isclose(cpd.slogl(df_null_float), cpd2.slogl( df_null_float))), "Order of evidence changes slogl() result."
import pytest import numpy as np import pyarrow as pa import pandas as pd import pybnesian as pbn from scipy.stats import gaussian_kde from scipy.stats import norm from scipy.stats import multivariate_normal as mvn from scipy.special import logsumexp import util_test SIZE = 10000 SMALL_SIZE = 10 TEST_SIZE = 50 df = util_test.generate_normal_data(SIZE, seed=0) df_small = util_test.generate_normal_data(SMALL_SIZE, seed=0) df_float = df.astype('float32') df_small_float = df_small.astype('float32') def test_variable(): for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: cpd = pbn.CKDE(variable, evidence) assert cpd.variable() == variable def test_evidence(): for variable, evidence in [('a', []), ('b', ['a']), ('c', ['a', 'b']), ('d', ['a', 'b', 'c'])]: