def test_relation_numpy_dataview_digest():
x = np.zeros((2, 3, 4), dtype=np.bool)
view = relation_numpy_dataview(x)
view1 = relation_numpy_dataview(x)
assert_equals(_hexdigest(view), _hexdigest(view1))
y = np.ones((2, 3, 4), dtype=np.bool)
view1 = relation_numpy_dataview(y)
assert_not_equals(_hexdigest(view), _hexdigest(view1))
def test_relation_numpy_dataview_digest():
x = np.zeros((2, 3, 4), dtype=np.bool)
view = relation_numpy_dataview(x)
view1 = relation_numpy_dataview(x)
assert_equals(_hexdigest(view), _hexdigest(view1))
y = np.ones((2, 3, 4), dtype=np.bool)
view1 = relation_numpy_dataview(y)
assert_not_equals(_hexdigest(view), _hexdigest(view1))
def test_relation_numpy_dataview_digest_masked():
x = np.zeros((2, 2), dtype=np.bool)
y = np.zeros((2, 2), dtype=np.bool)
y[0, 0] = True
mask = np.zeros((2, 2))
mask[0, 0] = True
ma_x = ma.array(x, mask=mask)
ma_y = ma.array(y, mask=mask)
view = relation_numpy_dataview(ma_x)
view1 = relation_numpy_dataview(ma_y)
assert_equals(_hexdigest(view), _hexdigest(view1))
def test_relation_numpy_dataview_digest_masked():
x = np.zeros((2, 2), dtype=np.bool)
y = np.zeros((2, 2), dtype=np.bool)
y[0, 0] = True
mask = np.zeros((2, 2))
mask[0, 0] = True
ma_x = ma.array(x, mask=mask)
ma_y = ma.array(y, mask=mask)
view = relation_numpy_dataview(ma_x)
view1 = relation_numpy_dataview(ma_y)
assert_equals(_hexdigest(view), _hexdigest(view1))
def test_relation_numpy_dataview_pickle():
# not masked, int32
y = np.random.randint(-10, 10, size=(10, 10))
view = relation_numpy_dataview(y)
bstr = pickle.dumps(view)
view1 = pickle.loads(bstr)
assert_true((y == view1.toarray()).all())
# masked, int32
y = ma.array(y, mask=(np.random.uniform(size=(10, 10)) < 0.5))
view = relation_numpy_dataview(y)
bstr = pickle.dumps(view)
view1 = pickle.loads(bstr)
assert_true((y == view1.toarray()).all())
def test_relation_numpy_dataview_pickle():
# not masked, int32
y = np.random.randint(-10, 10, size=(10, 10))
view = relation_numpy_dataview(y)
bstr = pickle.dumps(view)
view1 = pickle.loads(bstr)
assert_true((y == view1.toarray()).all())
# masked, int32
y = ma.array(y, mask=(np.random.uniform(size=(10, 10)) < 0.5))
view = relation_numpy_dataview(y)
bstr = pickle.dumps(view)
view1 = pickle.loads(bstr)
assert_true((y == view1.toarray()).all())
def test_dense_vs_sparse():
# XXX: really belongs in irm test cases, but kernels has a nice cluster
# enumeration iterator
r = rng()
n = 5
raw = ma.array(
np.random.choice(np.arange(20), size=(n, n)),
mask=np.random.choice([False, True], size=(n, n)))
dense = [relation_numpy_dataview(raw)]
sparse = [sparse_relation_dataview(_tocsr(raw))]
domains = [n]
relations = [((0, 0), gp)]
defn = irm_definition(domains, relations)
def score_fn(data):
def f(assignments):
s = irm_initialize(defn, data, r=r, domain_assignments=assignments)
assign = sum(s.score_assignment(i)
for i in xrange(len(assignments)))
likelihood = s.score_likelihood(r)
return assign + likelihood
return f
product_assignments = tuple(map(list, map(permutation_iter, domains)))
dense_posterior = scores_to_probs(
np.array(map(score_fn(dense), it.product(*product_assignments))))
sparse_posterior = scores_to_probs(
np.array(map(score_fn(sparse), it.product(*product_assignments))))
assert_1d_lists_almost_equals(dense_posterior, sparse_posterior, places=3)
def test_dense_vs_sparse():
# XXX: really belongs in irm test cases, but kernels has a nice cluster
# enumeration iterator
r = rng()
n = 5
raw = ma.array(np.random.choice(np.arange(20), size=(n, n)),
mask=np.random.choice([False, True], size=(n, n)))
dense = [relation_numpy_dataview(raw)]
sparse = [sparse_relation_dataview(_tocsr(raw))]
domains = [n]
relations = [((0, 0), gp)]
defn = irm_definition(domains, relations)
def score_fn(data):
def f(assignments):
s = irm_initialize(defn, data, r=r, domain_assignments=assignments)
assign = sum(
s.score_assignment(i) for i in xrange(len(assignments)))
likelihood = s.score_likelihood(r)
return assign + likelihood
return f
product_assignments = tuple(map(list, map(permutation_iter, domains)))
dense_posterior = scores_to_probs(
np.array(map(score_fn(dense), it.product(*product_assignments))))
sparse_posterior = scores_to_probs(
np.array(map(score_fn(sparse), it.product(*product_assignments))))
assert_1d_lists_almost_equals(dense_posterior, sparse_posterior, places=3)
def test_one_binary_nonconj():
# 1 domain, 1 binary relation, nonconj
domains = [3]
def mk_relations(model):
return [((0, 0), model)]
relsize = (domains[0], domains[0])
data = [
relation_numpy_dataview(
ma.array(np.random.choice([False, True], size=relsize),
mask=np.random.random(size=relsize) > 0.8))
]
def mkparam():
return {'p': 0.05}
params = {0: mkparam()}
def kernel(s, r):
assign_resample(s, 10, r)
theta(s, r, tparams=params)
_test_convergence(domains, data, mk_relations(bbnc), mk_relations(bb),
kernel)
def test_two_binary():
# 1 domain, 2 binary relations
domains = [4]
def mk_relations(model):
return [((0, 0), model), ((0, 0), model)]
relsize = (domains[0], domains[0])
data = [
relation_numpy_dataview(
ma.array(np.random.choice([False, True], size=relsize),
mask=np.random.choice([False, True], size=relsize))),
relation_numpy_dataview(
ma.array(np.random.choice([False, True], size=relsize),
mask=np.random.choice([False, True], size=relsize))),
]
_test_convergence(domains, data, mk_relations(bb), mk_relations(bb),
assign)
def test_one_binary_one_ternary():
# 1 domain, 1 binary, 1 ternary
domains = [4]
def mk_relations(model):
return [((0, 0), model), ((0, 0, 0), model)]
relsize2 = (domains[0], domains[0])
relsize3 = (domains[0], domains[0], domains[0])
data = [
relation_numpy_dataview(
ma.array(np.random.choice([False, True], size=relsize2),
mask=np.random.choice([False, True], size=relsize2))),
relation_numpy_dataview(
ma.array(np.random.choice([False, True], size=relsize3),
mask=np.random.choice([False, True], size=relsize3))),
]
_test_convergence(domains, data, mk_relations(bb), mk_relations(bb),
assign)
def test_two_binary():
# 1 domain, 2 binary relations
domains = [4]
def mk_relations(model):
return [((0, 0), model), ((0, 0), model)]
relsize = (domains[0], domains[0])
data = [
relation_numpy_dataview(
ma.array(
np.random.choice([False, True], size=relsize),
mask=np.random.choice([False, True], size=relsize))),
relation_numpy_dataview(
ma.array(
np.random.choice([False, True], size=relsize),
mask=np.random.choice([False, True], size=relsize))),
]
_test_convergence(
domains, data, mk_relations(bb), mk_relations(bb), assign)
def test_one_binary_one_ternary():
# 1 domain, 1 binary, 1 ternary
domains = [4]
def mk_relations(model):
return [((0, 0), model), ((0, 0, 0), model)]
relsize2 = (domains[0], domains[0])
relsize3 = (domains[0], domains[0], domains[0])
data = [
relation_numpy_dataview(
ma.array(
np.random.choice([False, True], size=relsize2),
mask=np.random.choice([False, True], size=relsize2))),
relation_numpy_dataview(
ma.array(
np.random.choice(
[False, True], size=relsize3),
mask=np.random.choice([False, True], size=relsize3))),
]
_test_convergence(
domains, data, mk_relations(bb), mk_relations(bb), assign)
def test_one_binary_nonconj_kernel():
# 1 domain, 1 binary relation
domains = [4]
def mk_relations(model):
return [((0, 0), model)]
relsize = (domains[0], domains[0])
data = [relation_numpy_dataview(
ma.array(
np.random.choice([False, True], size=relsize),
mask=np.random.choice([False, True], size=relsize)))]
kernel = lambda s, r: assign_resample(s, 10, r)
_test_convergence(
domains, data, mk_relations(bb), mk_relations(bb), kernel)
def test_one_binary_nonconj_kernel():
# 1 domain, 1 binary relation
domains = [4]
def mk_relations(model):
return [((0, 0), model)]
relsize = (domains[0], domains[0])
data = [
relation_numpy_dataview(
ma.array(np.random.choice([False, True], size=relsize),
mask=np.random.choice([False, True], size=relsize)))
]
kernel = lambda s, r: assign_resample(s, 10, r)
_test_convergence(domains, data, mk_relations(bb), mk_relations(bb),
kernel)
def test_one_binary_nonconj():
# 1 domain, 1 binary relation, nonconj
domains = [3]
def mk_relations(model):
return [((0, 0), model)]
relsize = (domains[0], domains[0])
data = [relation_numpy_dataview(
ma.array(
np.random.choice([False, True], size=relsize),
mask=np.random.random(size=relsize) > 0.8))]
def mkparam():
return {'p': 0.05}
params = {0: mkparam()}
def kernel(s, r):
assign_resample(s, 10, r)
theta(s, r, tparams=params)
_test_convergence(
domains, data, mk_relations(bbnc), mk_relations(bb), kernel)
def test_relation_numpy_dataview_masked():
x = np.zeros((2, 3, 4), dtype=np.bool)
x = ma.masked_array(x, mask=np.ones(x.shape))
view = relation_numpy_dataview(x)
assert_is_not_none(view)
assert_equals(view.shape(), (2, 3, 4))
def test_relation_numpy_dataview_masked():
x = np.zeros((2, 3, 4), dtype=np.bool)
x = ma.masked_array(x, mask=np.ones(x.shape))
view = relation_numpy_dataview(x)
assert_is_not_none(view)
assert_equals(view.shape(), (2, 3, 4))
def test_compare_to_mixture_model():
r = rng()
N, D = 4, 5
Y = np.random.uniform(size=(N, D)) > 0.8
Y_rec = np.array([tuple(y) for y in Y], dtype=[('', bool)] * D)
mm_view = rec_numpy_dataview(Y_rec)
irm_view = relation_numpy_dataview(Y)
mm_def = mm_definition(N, [bb] * D)
irm_def = irm_definition([N, D], [((0, 1), bb)])
perms = list(permutation_iter(N))
assignment = perms[np.random.randint(0, len(perms))]
mm_s = mm_initialize(mm_def, mm_view, r=r, assignment=assignment)
irm_s = irm_initialize(irm_def, [irm_view],
r=r,
domain_assignments=[
assignment,
range(D),
])
def assert_suff_stats_equal():
assert set(mm_s.groups()) == set(irm_s.groups(0))
assert irm_s.groups(1) == range(D)
groups = mm_s.groups()
for g in groups:
for i in xrange(D):
a = mm_s.get_suffstats(g, i)
b = irm_s.get_suffstats(0, [g, i])
if b is None:
b = {'heads': 0L, 'tails': 0L}
assert a['heads'] == b['heads'] and a['tails'] == b['tails']
assert_suff_stats_equal()
assert_almost_equals(mm_s.score_assignment(),
irm_s.score_assignment(0),
places=3)
bound_mm_s = mm_bind(mm_s, mm_view)
bound_irm_s = irm_bind(irm_s, 0, [irm_view])
# XXX: doesn't really have to be true, just is true of impl
assert not bound_mm_s.empty_groups()
assert not bound_irm_s.empty_groups()
bound_mm_s.create_group(r)
bound_irm_s.create_group(r)
gid_a = bound_mm_s.remove_value(0, r)
gid_b = bound_irm_s.remove_value(0, r)
assert gid_a == gid_b
assert_suff_stats_equal()
x0, y0 = bound_mm_s.score_value(0, r)
x1, y1 = bound_irm_s.score_value(0, r)
assert x0 == x1 # XXX: not really a requirement
# XXX: should really normalize and then check
for a, b in zip(y0, y1):
assert_almost_equals(a, b, places=2)
def test_relation_numpy_dataview():
x = np.zeros((2, 3, 4), dtype=np.bool)
view = relation_numpy_dataview(x)
assert_is_not_none(view)
assert_equals(view.shape(), (2, 3, 4))
def test_compare_to_mixture_model():
r = rng()
N, D = 4, 5
Y = np.random.uniform(size=(N, D)) > 0.8
Y_rec = np.array([tuple(y) for y in Y], dtype=[('', bool)] * D)
mm_view = rec_numpy_dataview(Y_rec)
irm_view = relation_numpy_dataview(Y)
mm_def = mm_definition(N, [bb] * D)
irm_def = irm_definition([N, D], [((0, 1), bb)])
perms = list(permutation_iter(N))
assignment = perms[np.random.randint(0, len(perms))]
mm_s = mm_initialize(mm_def, mm_view, r=r, assignment=assignment)
irm_s = irm_initialize(irm_def,
[irm_view],
r=r,
domain_assignments=[
assignment,
range(D),
])
def assert_suff_stats_equal():
assert set(mm_s.groups()) == set(irm_s.groups(0))
assert irm_s.groups(1) == range(D)
groups = mm_s.groups()
for g in groups:
for i in xrange(D):
a = mm_s.get_suffstats(g, i)
b = irm_s.get_suffstats(0, [g, i])
if b is None:
b = {'heads': 0L, 'tails': 0L}
assert a['heads'] == b['heads'] and a['tails'] == b['tails']
assert_suff_stats_equal()
assert_almost_equals(
mm_s.score_assignment(), irm_s.score_assignment(0), places=3)
bound_mm_s = mm_bind(mm_s, mm_view)
bound_irm_s = irm_bind(irm_s, 0, [irm_view])
# XXX: doesn't really have to be true, just is true of impl
assert not bound_mm_s.empty_groups()
assert not bound_irm_s.empty_groups()
bound_mm_s.create_group(r)
bound_irm_s.create_group(r)
gid_a = bound_mm_s.remove_value(0, r)
gid_b = bound_irm_s.remove_value(0, r)
assert gid_a == gid_b
assert_suff_stats_equal()
x0, y0 = bound_mm_s.score_value(0, r)
x1, y1 = bound_irm_s.score_value(0, r)
assert x0 == x1 # XXX: not really a requirement
# XXX: should really normalize and then check
for a, b in zip(y0, y1):
assert_almost_equals(a, b, places=2)
def test_relation_numpy_dataview():
x = np.zeros((2, 3, 4), dtype=np.bool)
view = relation_numpy_dataview(x)
assert_is_not_none(view)
assert_equals(view.shape(), (2, 3, 4))
