def test_entropy_bernoulli_bivariate__ci_(): # Set the test parameters. integration = pytest.config.getoption('--integration') n_data = 250 if integration else 10 n_step = 20 if integration else 1 n_samp = 1000 if integration else 10 prng = get_prng(10) # Generate a bivariate Bernoulli dataset. PX = [.3, .7] PY = [[.2, .8], [.6, .4]] TX = prng.choice([0, 1], p=PX, size=n_data) TY = np.zeros(shape=len(TX)) TY[TX == 0] = prng.choice([0, 1], p=PY[0], size=len(TX[TX == 0])) TY[TX == 1] = prng.choice([0, 1], p=PY[1], size=len(TX[TX == 1])) T = np.column_stack((TY, TX)) # Create ensemble. ensemble = CrossCatEnsemble( outputs=[0, 1], inputs=[], distributions=[('bernoulli', None)] * 2, Cd=[[0, 1]], chains=64, rng=prng, ) # Observe data. for rowid, (x, y) in enumerate(T): ensemble.observe(rowid, {0: x, 1: y}) # Run inference. program = make_custom_program(N=n_step) ensemble.transition(program, multiprocess=1) # Exact computation. entropy_exact = (-PX[0] * PY[0][0] * np.log(PX[0] * PY[0][0]) - PX[0] * PY[0][1] * np.log(PX[0] * PY[0][1]) - PX[1] * PY[1][0] * np.log(PX[1] * PY[1][0]) - PX[1] * PY[1][1] * np.log(PX[1] * PY[1][1])) # logpdf computation. logps = ensemble.logpdf_bulk(None, [{ 0: 0, 1: 0 }, { 0: 0, 1: 1 }, { 0: 1, 1: 0 }, { 0: 1, 1: 1 }]) entropy_logpdf = [-np.sum(np.exp(logp) * logp) for logp in logps] # Mutual_information computation. n_samp = 10 if not integration else 1000 entropy_mi_estimates = ensemble.mutual_information([0, 1], [0, 1], N=n_samp) entropy_mi = [estimate.mean for estimate in entropy_mi_estimates] # Punt CLT analysis and go for a small tolerance. assert not integration or np.allclose( entropy_exact, entropy_logpdf, atol=.1) assert not integration or np.allclose(entropy_exact, entropy_mi, atol=.1) assert not integration or np.allclose(entropy_logpdf, entropy_mi, atol=.1)
def __init__(self, outputs, inputs, hypers=None, params=None, distargs=None, rng=None): # Populate default kwargs. hypers = hypers or dict() params = params or dict() distargs = distargs or dict() # From constructor. self.outputs = list(outputs) self.inputs = list(inputs) self.params = params self.rng = rng or get_prng(1) # Internal attributes. self.data = OrderedDict() self.N = 0 self.sum_x = 0 self.sum_log_fact_x = 0 self.a = hypers.get('a', 1.) self.b = hypers.get('b', 1.) assert self.a > 0 assert self.b > 0
def __init__(self, outputs, inputs, hypers=None, params=None, distargs=None, rng=None): # Populate default kwargs. hypers = hypers or dict() params = params or dict() distargs = distargs or dict() # From constructor. self.outputs = list(outputs) self.inputs = list(inputs) self.params = params self.rng = rng or get_prng(1) # Internal attributes. self.data = OrderedDict() self.N = 0 self.sum_x = 0 self.sum_x_sq = 0 self.m = hypers.get('m', 0.) self.r = hypers.get('r', 1.) self.s = hypers.get('s', 1.) self.nu = hypers.get('nu', 1.) assert self.s > 0. assert self.r > 0. assert self.nu > 0.
def __init__(self, outputs, inputs, distributions, chains=1, Cd=None, Ci=None, rng=None): # Assertion. assert len(outputs) == len(distributions) assert inputs == [] # From constructor. self.outputs = outputs self.inputs = inputs self.chains = chains self.distributions = distributions self.Cd = tuple(Cd or []) self.Ci = tuple(Ci or []) self.rng = rng or get_prng(1) # Derived attributes. self.chains_list = range(chains) seeds = self.rng.randint(0, 2**32 - 1, size=chains) self.cgpms = map(make_random_crosscat, [(outputs, distributions, self.Cd, self.Ci, seed) for seed in seeds])
def test_mutation_hypers_crp(): prng = get_prng(2) synthesizer = get_crosscat_synthesizer(prng) crp = synthesizer.crosscat.cgpms[0].cgpm_row_divide for v in np.linspace(0.01, 10, 1): synthesizer.set_hypers_row_divide(0, {'alpha': v}) assert crp.get_hypers()['alpha'] == v
def test_independence_inference_merge(): # Get lovecat to merge dependent columns into one view. prng = get_prng(582) data = get_independence_inference_data(prng) # Hack: Use Cd/Ci to initialize CrossCat as # {0:0, 1:0, 2:1, 3:1, 4:2, 5:2, 6:3, 7:3} Cd = ((0, 1), (2, 3), (4, 5), (6, 7)) Ci = ((0, 2), (0, 4), (0, 6), (2, 4), (2, 6), (4, 6)) ensemble = CrossCatEnsemble(outputs=range(8), inputs=[], distributions=[('normal', None)] * 8, chains=1, Cd=Cd, Ci=Ci, rng=prng) ensemble.Ci = () incorporate_data(ensemble, data) ensemble.transition(ensemble.make_default_inference_program(N=100)) crosscat = ensemble.cgpms[0] Zv = {c: i for i, cgpm in enumerate(crosscat.cgpms) for c in cgpm.outputs} for output in [ 0, 1, 2, 3, ]: assert Zv[output] == Zv[0] for output in [4, 5, 6, 7]: assert Zv[output] == Zv[4] assert len(crosscat.cgpms) == 2
def test_convert_cgpm_to_cgpm2(): prng = get_prng(2) data = np.concatenate(( prng.normal(loc=0, scale=2, size=20), prng.normal(loc=30, scale=1, size=20), prng.normal(loc=-30, scale=1, size=20), )) state = State(X=np.reshape(data, (len(data), 1)), outputs=[0], cctypes=['normal'], rng=prng) view_cgpm1 = state.views[0] view_cgpm1.transition(N=5) # Convert product = convert_cgpm_state_to_cgpm2(state, prng) view_cgpm2 = product.cgpms[0] # Verify row assignments. assignments0 = view_cgpm1.Zr() partition0 = [[r for r, z in assignments0.iteritems() if z == u] for u in set(assignments0.values())] assignments1 = view_cgpm2.cgpm_row_divide.data partition1 = [[r for r, z in assignments1.iteritems() if z == u] for u in set(assignments1.values())] partition0_sorted = sorted(partition0, key=min) partition1_sorted = sorted(partition1, key=min) assert partition0_sorted == partition1_sorted # Verify hyperparameters. hypers0 = view_cgpm1.dims[0].hypers hypers1 = view_cgpm2.cgpm_components_array.cgpm_base.cgpms[0].get_hypers() assert hypers0 == hypers1 # Verify CRP alpha. alpha0 = view_cgpm1.crp.hypers alpha1 = view_cgpm2.cgpm_row_divide.get_hypers() assert alpha0 == alpha1
def test_transition_hypers_basic(): prng = get_prng(2) component0 = Product([ Poisson([0], [], hypers={'m': 100}, rng=prng), Normal([1], [], hypers={'m': 100}, rng=prng) ], rng=prng) cgpm_row_divide = CRP([2], [], rng=prng) infinite_mixture = FlexibleRowMixture(cgpm_row_divide=cgpm_row_divide, cgpm_components_base=component0, rng=prng) # Make normal observations. infinite_mixture.observe(0, {1: 100}) infinite_mixture.observe(1, {1: 300}) infinite_mixture.observe(2, {1: -300}) # Fetch log score. log_score0 = infinite_mixture.logpdf_score() # Run inference. normal_cgpms = get_cgpms_by_output_index(infinite_mixture, 1) grids_normal = transition_hyper_grids(normal_cgpms, 30) hypers_normal = [ transition_hypers(normal_cgpms, grids_normal, prng) for _i in xrange(2) ] assert not all(hypers == hypers_normal[0] for hypers in hypers_normal) log_score1 = infinite_mixture.logpdf_score() assert log_score0 < log_score1
def test_entropy_bernoulli_univariate__ci_(): integration = pytest.config.getoption('--integration') n_data = 250 if integration else 10 n_step = 10 if integration else 1 n_samp = 1000 if integration else 10 prng = get_prng(10) # Generate a biased Bernoulli dataset. T = prng.choice([0, 1], p=[.3, .7], size=n_data) # Create ensemble. ensemble = CrossCatEnsemble( outputs=[0], inputs=[], distributions=[('bernoulli', None)], chains=16, rng=prng, ) # Observe data. for rowid, x in enumerate(T): ensemble.observe(rowid, {0: x}) # Run inference. program = make_custom_program(N=n_step) ensemble.transition(program, multiprocess=1) # Exact computation. entropy_exact = -(.3 * np.log(.3) + .7 * np.log(.7)) # logpdf computation. logps = ensemble.logpdf_bulk(None, [{0: 0}, {0: 1}]) entropy_logpdf = [-np.sum(np.exp(logp) * logp) for logp in logps] # Mutual_information computation. entropy_mi_estimates = ensemble.mutual_information([0], [0], N=n_samp) entropy_mi = [estimate.mean for estimate in entropy_mi_estimates] # Punt CLT analysis and go for 1 decimal place. assert not integration or np.allclose( entropy_exact, entropy_logpdf, atol=.1) assert not integration or np.allclose(entropy_exact, entropy_mi, atol=.1) assert not integration or np.allclose(entropy_logpdf, entropy_mi, atol=.05)
def test_mutation_hypers_component(): prng = get_prng(2) synthesizer = get_crosscat_synthesizer(prng) normals = get_distribution_cgpms(synthesizer.crosscat, [0])[0] for v in np.linspace(0.01, 10, 1): synthesizer.set_hypers_distribution(0, {'m': v}) for cgpm in normals: assert cgpm.get_hypers()['m'] == v
def test_dependencies_zero_based(): prng = get_prng(2) CrossCatEnsemble(outputs=(1, 2), inputs=(), Ci=[(1, 2)], distributions=[('normal', None)] * 2, chains=5, rng=prng)
def test_flexible_mixture_three_component__ci_(): prng = get_prng(2) flexible_mixture = FlexibleRowMixture(cgpm_row_divide=CRP([1], [], rng=prng), cgpm_components_base=Normal( [0], [], rng=prng), rng=prng) integration = pytest.config.getoption('--integration') run_mixture_test(flexible_mixture, integration, prng)
def test_mutation_set_view_assignment(): prng = get_prng(2) synthesizer = get_crosscat_synthesizer(prng) # Move column 0 zero to singleton view. synthesizer.set_view_assignment(0, None) assert len(synthesizer.crosscat.cgpms) == 2 # Move column 1 to view of column 0. synthesizer.set_view_assignment(1, 0) assert len(synthesizer.crosscat.cgpms) == 1
def test_crosscat_two_component_nominal__ci_(): prng = get_prng(10) integration = pytest.config.getoption('--integration') # Build CGPM with adversarial initialization. crosscat = Product([ FlexibleRowMixture( cgpm_row_divide=CRP([-1], [], rng=prng), cgpm_components_base=Product([ Normal([0], [], rng=prng), ], rng=prng), rng=prng), FlexibleRowMixture( cgpm_row_divide=CRP([-2], [], rng=prng), cgpm_components_base=Product([ Normal([1], [], rng=prng), Categorical([50], [], distargs={'k':4}, rng=prng), ], rng=prng), rng=prng), ], rng=prng,) # Fetch data and add a nominal variable. data_xy = make_bivariate_two_clusters(prng) data_z = np.zeros(len(data_xy)) data_z[:15] = 0 data_z[15:30] = 1 data_z[30:45] = 2 data_z[45:60] = 3 data = np.column_stack((data_xy, data_z)) # Observe. for rowid, row in enumerate(data): crosscat.observe(rowid, {0: row[0], 1: row[1], 50:row[2]}) # Run inference. synthesizer = GibbsCrossCat(crosscat) synthesizer.transition(N=(50 if integration else 1), progress=False) synthesizer.transition(N=(100 if integration else 1), kernels=['hypers_distributions','hypers_row_divide'], progress=False) # Assert views are merged into one. assert not integration or len(synthesizer.crosscat.cgpms) == 1 crp_output = synthesizer.crosscat.cgpms[0].cgpm_row_divide.outputs[0] # Check joint samples for all nominals. samples = synthesizer.crosscat.simulate(None, [crp_output,0,1,50], N=250) not integration or check_sampled_data(samples, [0, 7], 3, 110) # Check joint samples for nominals [0, 2]. samples_a = [s for s in samples if s[50] in [0,2]] not integration or check_sampled_data(samples_a, [0, 7], 3, 45) # Check joint samples for nominals [1, 3]. samples_b = [s for s in samples if s[50] in [1,3]] not integration or check_sampled_data(samples_b, [0, 7], 3, 45) # Check conditional samples in correct quadrants. means = {0:0, 1:0, 2:7, 3:7} for z in [0, 1, 2, 3]: samples = synthesizer.crosscat.simulate(None, [0, 1], {50:z}, N=100) not integration or check_sampled_data(samples, [means[z]], 3, 90)
def __init__(self, cgpms, indexer, rng=None): # From constructor. self.cgpms = cgpms self.rng = rng or get_prng(1) # Derived attributes. self.outputs = self.cgpms[0].outputs self.inputs = [indexer] + self.cgpms[0].inputs self.indexer = indexer # Internal attributes. self.rowid_to_index = {}
def test_logpdf_basic(): prng = get_prng(2) crosscat = get_crosscat(prng) crosscat = populate_crosscat(crosscat, prng) for _rowid, row in get_dataset(crosscat, 0): logp = crosscat.logpdf(None, row) if np.isnan(row.values()[0]): assert np.allclose(logp, 0) else: assert logp < 0
def test_dependencies_no_cpp(): prng = get_prng(2) ensemble = CrossCatEnsemble(outputs=(0, 1), inputs=[], Ci=[(0, 1)], distributions=[('normal', None)] * 2, chains=5, rng=prng) ensemble.observe(0, {0: 0, 1: 1}) synthesizer = GibbsCrossCat(ensemble.cgpms[0], Ci=ensemble.Ci) synthesizer.transition_view_assignments()
def __init__(self, cgpms, rng=None): # Assertions. validate_cgpms_product(cgpms) # From constructor. self.cgpms = flatten_cgpms(cgpms, Product) self.rng = rng or get_prng(1) # Derived attributes. self.outputs = lchain(*[cgpm.outputs for cgpm in self.cgpms]) self.inputs = lchain(*[cgpm.inputs for cgpm in self.cgpms]) self.output_to_index = {output:i for i, cgpm in enumerate(self.cgpms) for output in cgpm.outputs}
def make_random_crosscat((outputs, distributions, Cd, Ci, seed)): rng = get_prng(seed) alpha = rng.gamma(2, 1) N = len(outputs) partition = make_random_partition(N, alpha, Cd, Ci, rng) views = [ make_random_view(outputs=[outputs[i] for i in block], distributions=[distributions[i] for i in block], rng=rng) for block in partition ] crosscat = Product(cgpms=views, rng=rng) return crosscat
def test_simple_product(): prng = get_prng(2) column0 = Normal([0], [], rng=prng) column1 = Normal([1], [], rng=prng) column2 = Categorical([2], [], distargs={'k':4}, rng=prng) product = Product([column0, column1, column2], prng) assert product.outputs == [0,1,2] assert product.inputs == [] sample = product.simulate(None, [1,2,0]) assert set(sample.keys()) == set([1, 2, 0]) logp = product.logpdf(None, sample) assert logp < 0
def test_finite_mixture_three_component__ci_(): prng = get_prng(2) finite_mixture = FiniteRowMixture( cgpm_row_divide=Categorical([1], [], distargs={'k': 3}, rng=prng), cgpm_components=[ Normal([0], [], rng=prng), Normal([0], [], rng=prng), Normal([0], [], rng=prng) ], rng=prng, ) integration = pytest.config.getoption('--integration') run_mixture_test(finite_mixture, integration, prng)
def test_crosscat_two_component_no_view__ci_(): prng = get_prng(10) integration = pytest.config.getoption('--integration') crosscat = get_crosscat(prng) def func_inference(crosscat): synthesizer = GibbsCrossCat(crosscat) n_step = 500 if integration else 1 for _step in xrange(n_step): synthesizer.transition_row_assignments() synthesizer.transition_hypers_distributions() synthesizer.transition_hypers_row_divide() return synthesizer run_crosscat_test(crosscat, func_inference, integration, prng)
def test_crosscat_two_component_cpp__ci_(): prng = get_prng(10) integration = pytest.config.getoption('--integration') crosscat = get_crosscat(prng) def func_inference(crosscat): synthesizer = GibbsCrossCat(crosscat) n_step = 1000 if integration else 1 synthesizer = GibbsCrossCat(crosscat) synthesizer.transition_structure_cpp(N=n_step) synthesizer.transition_hypers_distributions() synthesizer.transition_hypers_row_divide() return synthesizer run_crosscat_test(crosscat, func_inference, integration, prng)
def test_simple_product_as_chain(): prng = get_prng(2) component0 = Chain([ Poisson([0], [], hypers={'a': 10, 'b': 1}, rng=prng), Normal([1], [], hypers={'m':100}, rng=prng) ], rng=prng) cgpm_row_divide = CRP([2], [], rng=prng) infinite_mixture = FlexibleRowMixture( cgpm_row_divide=cgpm_row_divide, cgpm_components_base=component0, rng=prng) assert infinite_mixture.cgpm_row_divide.support() == [0] # Test logpdf identities. lp0 = infinite_mixture.logpdf(None, {0:1}) assert lp0 < 0 lp1 = infinite_mixture.logpdf(None, {0:1, 2:0}) assert np.allclose(lp0, lp1) lp2 = infinite_mixture.logpdf(None, {0:1, 2:1}) assert lp2 == -float('inf') # Add an observation. infinite_mixture.observe(0, {1:100}) lp0 = infinite_mixture.logpdf(None, {1:100, 2:0}, constraints={0:1}) lp1 = infinite_mixture.logpdf(None, {1:100, 2:1}, constraints={0:1}) lp2 = infinite_mixture.logpdf(None, {1:100, 2:2}, constraints={0:1}) assert lp1 < lp0 assert lp2 == float('-inf') # Remove observation. observation = infinite_mixture.unobserve(0) assert observation == ({1:100, 2:0}, {}) # Remove observation again. with pytest.raises(Exception): infinite_mixture.unobserve(0) # Add more observations. infinite_mixture.observe(0, {1:100}) infinite_mixture.observe(1, {1:300}) infinite_mixture.observe(2, {0:2}) # Constrained cluster has zero density. with pytest.raises(ValueError): infinite_mixture.logpdf(None, {0:1}, constraints={2:10}) with pytest.raises(ValueError): infinite_mixture.logpdf(None, {0:1}, constraints={2:10}) # Convert to/from metadata and assert unobserves return correct data. metadata = infinite_mixture.to_metadata() infinite_mixture2 = FlexibleRowMixture.from_metadata(metadata, prng) assert infinite_mixture2.unobserve(0) == \ ({1:100, 2: infinite_mixture.cgpm_row_divide.data[0]}, {}) assert infinite_mixture2.unobserve(1) == \ ({1:300, 2: infinite_mixture.cgpm_row_divide.data[1]}, {}) assert infinite_mixture2.unobserve(2) == \ ({0:2, 2: infinite_mixture.cgpm_row_divide.data[2]}, {})
def __init__(self, cgpms, accuracy=None, rng=None): # Validate inputs. cgpms_valid = validate_cgpms(cgpms) # From constructor self.cgpms = flatten_cgpms(cgpms_valid, Chain) self.accuracy = accuracy or 1 self.rng = rng if rng else get_prng(1) # Derived attributes. self.outputs = lchain(*[cgpm.outputs for cgpm in self.cgpms]) self.inputs = lchain(*[cgpm.inputs for cgpm in self.cgpms]) self.v_to_c = retrieve_variable_to_cgpm(self.cgpms) self.adjacency = retrieve_adjacency_list(self.cgpms, self.v_to_c) self.extraneous = retrieve_extraneous_inputs(self.cgpms, self.v_to_c) self.topo = topological_sort(self.adjacency)
def test_crosscat_add_remove(): prng = get_prng(2) crosscat = get_crosscat(prng) infinite_mixture4 = FlexibleRowMixture( cgpm_row_divide=CRP([-4], [], rng=prng), cgpm_components_base=Product([ Categorical([6], [], distargs={'k':4}, rng=prng), ], rng=prng), rng=prng) crosscat = add_cgpm(crosscat, infinite_mixture4) assert crosscat.outputs == [-1, 0, 1, -2, 2, 3, 4, -3, 5, -4, 6] crosscat = remove_cgpm(crosscat, -1) assert crosscat.outputs == [-2, 2, 3, 4, -3, 5, -4, 6] crosscat = remove_cgpm(crosscat, 5) assert crosscat.outputs == [-2, 2, 3, 4, -4, 6]
def test_custom_independence(Ci): prng = get_prng(1) D = prng.normal(size=(10, 1)) T = np.repeat(D, 10, axis=1) ensemble = CrossCatEnsemble(outputs=range(10), inputs=[], distributions=[('normal', None)] * 10, chains=5, Ci=Ci, rng=prng) incorporate_data(ensemble, T) for crosscat in ensemble.cgpms: validate_crosscat_dependencies(crosscat, (), Ci) ensemble.transition(ensemble.make_default_inference_program(N=10)) for crosscat in ensemble.cgpms: validate_crosscat_dependencies(crosscat, (), Ci)
def test_transition_crp_mixture(): prng = get_prng(2) data = np.concatenate(( prng.normal(loc=0, scale=2, size=20), prng.normal(loc=30, scale=1, size=20), prng.normal(loc=-30, scale=1, size=20), )) infinite_mixture = FlexibleRowMixture(cgpm_row_divide=CRP([1], [], rng=prng), cgpm_components_base=Normal( [0], [], rng=prng), rng=prng) for rowid, value in enumerate(data): infinite_mixture.observe(rowid, {0: value}) cgpms = { 0: get_cgpms_by_output_index(infinite_mixture, 0), 1: get_cgpms_by_output_index(infinite_mixture, 1), } grids = { 0: transition_hyper_grids(cgpms[0], 30), 1: transition_hyper_grids(cgpms[1], 30), } for _step in xrange(50): rowids = prng.permutation(range(len(data))) for rowid in rowids: transition_rows(infinite_mixture, rowid, prng) for output in infinite_mixture.outputs: transition_hypers(cgpms[output], grids[output], prng) rowids = range(60) assignments0 = [ infinite_mixture.simulate(r, [1])[1] for r in rowids[00:20] ] assignments1 = [ infinite_mixture.simulate(r, [1])[1] for r in rowids[20:40] ] assignments2 = [ infinite_mixture.simulate(r, [1])[1] for r in rowids[40:60] ] mode0 = Counter(assignments0).most_common(1)[0][0] mode1 = Counter(assignments1).most_common(1)[0][0] mode2 = Counter(assignments2).most_common(1)[0][0] assert sum(a == mode0 for a in assignments0) > int(0.95 * len(assignments0)) assert sum(a == mode1 for a in assignments1) > int(0.95 * len(assignments1)) assert sum(a == mode2 for a in assignments2) > int(0.95 * len(assignments2))
def test_transition_rows_fixed_mixture(): prng = get_prng(2) component0 = Product([ Normal([0], [], hypers={'m':1000}, rng=prng), Normal([1], [], hypers={'m':0}, rng=prng) ], rng=prng) component1 = Product([ Normal([0], [], hypers={'m':-1000}, rng=prng), Normal([1], [], hypers={'m':1000}, rng=prng) ], rng=prng) component2 = Product([ Normal([0], [], hypers={'m':0}, rng=prng), Normal([1], [], hypers={'m':-100}, rng=prng) ], rng=prng) cgpm_row_divide = Categorical([2], [], distargs={'k':3}, rng=prng) finite_mixture = FiniteRowMixture( cgpm_row_divide=cgpm_row_divide, cgpm_components=[component0, component1, component2], rng=prng) # For component 0. finite_mixture.observe(0, {0:1000, 1:0, 2:0}) finite_mixture.observe(1, {0:990, 1:-10, 2:0}) # For component 1. finite_mixture.observe(2, {0:-1000, 1:1000, 2:0}) finite_mixture.observe(3, {0:-990, 1:990, 2:0}) # For component 2. finite_mixture.observe(4, {0:0, 1:-1000, 2:0}) finite_mixture.observe(5, {0:10, 1:-990, 2:0}) # Confirm all rows in component 0. assert finite_mixture.simulate(0, [2]) == {2:0} assert finite_mixture.simulate(1, [2]) == {2:0} assert finite_mixture.simulate(2, [2]) == {2:0} assert finite_mixture.simulate(3, [2]) == {2:0} assert finite_mixture.simulate(4, [2]) == {2:0} assert finite_mixture.simulate(5, [2]) == {2:0} # Run transitions for _i in xrange(10): for rowid in range(6): transition_rows(finite_mixture, rowid, prng) # Confirm all rows in correct components. assert finite_mixture.simulate(0, [2]) == {2:0} assert finite_mixture.simulate(1, [2]) == {2:0} assert finite_mixture.simulate(2, [2]) == {2:1} assert finite_mixture.simulate(3, [2]) == {2:1} assert finite_mixture.simulate(4, [2]) == {2:2} assert finite_mixture.simulate(5, [2]) == {2:2}
def test_mutation_set_rowid_component(): prng = get_prng(2) synthesizer = get_crosscat_synthesizer(prng) crp = synthesizer.crosscat.cgpms[0].cgpm_row_divide # Move row 0 to singleton component. synthesizer.set_rowid_component(0, 0, None) new_cluster = crp.data[0] assert crp.counts[new_cluster] == 1 # Move row 0 to singleton component again. synthesizer.set_rowid_component(0, 0, None) new_cluster_prime = crp.data[0] assert new_cluster_prime == new_cluster assert crp.counts[new_cluster_prime] == 1 # Move row 10 to component of row 0. synthesizer.set_rowid_component(0, 10, 0) assert crp.data[10] == new_cluster_prime assert crp.counts[new_cluster_prime] == 2