def test_simulate_bulk__ci_(engine):
engine = Engine.from_metadata(engine)
rowid1, targets1, constraints1, N1, = -1, [0, 2, 4, 5], {3: 1}, 7
rowid2, targets2, constraints2, N2 = 5, [1, 3], {2: 1}, 3
rowid3, targets3, constraints3, N3 = 8, [0], {4: .8}, 3
# Bulk.
rowids = [rowid1, rowid2, rowid3]
targets_list = [targets1, targets2, targets3]
constraints_list = [constraints1, constraints2, constraints3]
Ns = [N1, N2, N3]
def test_correct_dimensions(statenos):
# Invoke
samples = engine.simulate_bulk(rowids,
targets_list,
constraints_list=constraints_list,
Ns=Ns,
statenos=statenos)
assert len(samples) == (engine.num_states()
if statenos is None else len(statenos))
for states_samples in samples:
assert len(states_samples) == len(rowids)
for i, sample in enumerate(states_samples):
assert len(sample) == Ns[i]
for s in sample:
assert set(s.keys()) == set(targets_list[i])
assert len(s) == len(targets_list[i])
test_correct_dimensions(None)
test_correct_dimensions([4])
def _engine(self, bdb, generator_id):
# Probe the cache.
cache = self._cache(bdb)
if cache is not None and generator_id in cache.engine:
return cache.engine[generator_id]
# Not cached. Load the engine from the database.
cursor = bdb.sql_execute(
'''
SELECT engine_json FROM bayesdb_cgpm_generator
WHERE generator_id = ?
''', (generator_id, ))
engine_json = cursor_value(cursor)
if engine_json is None:
generator = core.bayesdb_generator_name(bdb, generator_id)
raise BQLError(
bdb, 'No models initialized for generator: %r' % (generator, ))
# Deserialize the engine.
engine = Engine.from_metadata(json.loads(engine_json),
rng=bdb.np_prng,
multiprocess=self._ncpu)
# Cache it, if we can.
if cache is not None:
cache.engine[generator_id] = engine
return engine
def test_logpdf_bulk__ci_(engine):
engine = Engine.from_metadata(engine)
rowid1, targets1, constraints1 = 5, {0: 0}, {2: 1, 3: .5}
rowid2, targets2, constraints2 = -1, {1: 0, 4: .8}, {5: .5}
# Bulk.
rowids = [rowid1, rowid2]
targets_list = [targets1, targets2]
constraints_list = [constraints1, constraints2]
def test_correct_dimensions(statenos):
# Invoke
logpdfs = engine.logpdf_bulk(rowids,
targets_list,
constraints_list=constraints_list,
statenos=statenos)
assert len(logpdfs) == \
engine.num_states() if statenos is None else len(statenos)
for state_logpdfs in logpdfs:
# state_logpdfs should be a list of floats, one float per targets.
assert len(state_logpdfs) == len(rowids)
for l in state_logpdfs:
assert isinstance(l, float)
test_correct_dimensions(statenos=None)
test_correct_dimensions(statenos=[0, 1, 4, 5])
def test_row_similarity__ci_(engine):
engine = Engine.from_metadata(engine)
results = engine.row_similarity(0, 2, statenos=None)
assert len(results) == engine.num_states()
results = engine.row_similarity(0, 2, statenos=[1, 4, 5])
assert len(results) == 3
def test_dependence_probability__ci_(engine):
engine = Engine.from_metadata(engine)
results = engine.dependence_probability(0, 2, statenos=None)
assert len(results) == engine.num_states()
results = engine.dependence_probability(0, 2, statenos=[1, 4])
assert len(results) == 2
def _populate_from_metadata(model, metadata):
model.initialized = metadata['initialized']
model.dataset = pd.DataFrame(metadata['dataset.values'],
index=metadata['dataset.index'],
columns=metadata['dataset.columns'])
model.engine = Engine.from_metadata(metadata['engine']) \
if model.initialized else None
return model
def test_relevance_probability__ci_(engine):
engine = Engine.from_metadata(engine)
results = engine.relevance_probability(0, [2, 14], 0, statenos=None)
assert len(results) == engine.num_states()
results = engine.relevance_probability(0, [2, 14],
0,
statenos=range(engine.num_states()))
assert len(results) == engine.num_states()
def from_metadata(metadata, seed):
model = TRCRP_Mixture(
chains=metadata['chains'],
lag=metadata['lag'],
variables=metadata['variables'],
rng=np.random.RandomState(seed),
)
# Internal fields.
model.initialized = metadata['initialized']
model.dataset = pd.DataFrame(metadata['dataset.values'],
index=metadata['dataset.index'],
columns=metadata['dataset.columns'])
model.engine = Engine.from_metadata(metadata['engine']) \
if model.initialized else None
return model
def test_simulate__ci_(engine):
engine = Engine.from_metadata(engine)
def test_correct_dimensions(rowid, targets, constraints, N, statenos):
samples = engine.simulate(rowid,
targets,
constraints=constraints,
N=N,
statenos=statenos)
assert len(samples) == (engine.num_states()
if statenos is None else len(statenos))
for states_samples in samples:
# Each element of samples should be a list of N samples.
assert len(states_samples) == N
for s in states_samples:
# Each raw sample should be len(Q) dimensional.
assert set(s.keys()) == set(targets)
assert len(s) == len(targets)
s = engine._likelihood_weighted_resample(samples,
rowid,
constraints=constraints,
statenos=statenos)
assert len(s) == N
targets1, constraints1 = [0], {2: 0, 3: 6}
targets2, constraints2 = [1, 2, 5], {0: 3, 3: .8}
for statenos in (None, (1, 3)):
test_correct_dimensions(-1, targets1, constraints1, 1, statenos)
test_correct_dimensions(-1, targets1, constraints1, 8, statenos)
test_correct_dimensions(-1, targets2, constraints2, 1, statenos)
test_correct_dimensions(-1, targets2, constraints2, 8, statenos)
targets3, constraints3 = [0, 1, 2], {3: 1}
test_correct_dimensions(5, targets3, constraints3, 1, statenos)
test_correct_dimensions(5, targets3, constraints3, 8, statenos)
def test_logpdf__ci_(engine):
engine = Engine.from_metadata(engine)
def test_correct_dimensions(rowid, targets, constraints, statenos):
# logpdfs should be a list of floats.
logpdfs = engine.logpdf(rowid,
targets,
constraints=constraints,
statenos=statenos)
assert len(logpdfs) == (engine.num_states()
if statenos is None else len(statenos))
for state_logpdfs in logpdfs:
# Each element in logpdfs should be a single float.
assert isinstance(state_logpdfs, float)
lp = engine._likelihood_weighted_integrate(logpdfs,
rowid,
constraints=constraints,
statenos=statenos)
assert isinstance(lp, float)
for statenos in (None, [0, 2, 4]):
test_correct_dimensions(-1, {0: 1}, {2: 1, 3: .5}, statenos)
test_correct_dimensions(-1, {2: 0, 5: 3}, {0: 4, 1: 5}, statenos)
test_correct_dimensions(5, {0: 0, 2: 0}, {3: 3}, statenos)
def test_incorporate_engine():
engine = Engine(
T[:,:2],
cctypes=CCTYPES[:2],
distargs=DISTARGS[:2],
num_states=4,
rng=gu.gen_rng(0),
)
engine.transition(N=5)
# Incorporate a new dim into with a non-contiguous output.
engine.incorporate_dim(
T[:,2],
outputs=[10],
cctype=CCTYPES[2],
distargs=DISTARGS[2]
)
engine.transition(N=2)
# Serialize the engine, and run a targeted transtion on variable 10.
m = engine.to_metadata()
engine2 = Engine.from_metadata(m)
engine2.transition(N=2, cols=[10], multiprocess=0)
assert all(s.outputs == [0,1,10] for s in engine.states)
