def test_filter_grad():
def compare_grads(lds):
init_params, pair_params, node_params = lds
dotter = randn_like(
natural_filter_forward_general(init_params, pair_params,
node_params)[0])
def messages_to_scalar(messages):
return contract(dotter, messages)
def py_fun(node_params):
messages, lognorm = natural_filter_forward_general(
init_params, pair_params, node_params)
return np.cos(lognorm) + messages_to_scalar(messages)
def cy_fun(node_params):
dense_messages, lognorm = _natural_filter_forward_general(
init_params, pair_params, node_params)
messages = unpack_dense_messages(dense_messages)
return np.cos(lognorm) + messages_to_scalar(messages)
g_py = grad(py_fun)(node_params)
g_cy = grad(cy_fun)(node_params)
assert allclose(g_py, g_cy)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_grads, rand_lds(n, T)
def helper(homog):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10,50)
lds = rand_lds(n, p, None if homog else T)
states, data = generate_data(T, *lds)
natparam = lds_standard_to_natparam(*lds)
E_stats = natural_lds_Estep(natparam, data)
assert allclose(sub(add(natparam, E_stats), E_stats), natparam)
def test_smoother_grads():
def compare_smoother_grads(lds):
init_params, pair_params, node_params = lds
symmetrize = make_unop(lambda x: (x + x.T)/2. if np.ndim(x) == 2 else x, tuple)
messages, _ = natural_filter_forward_general(*lds)
dotter = randn_like(natural_smoother_general(messages, *lds))
def py_fun(messages):
result = natural_smoother_general(messages, *lds)
assert shape(result) == shape(dotter)
return contract(dotter, result)
dense_messages, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
def cy_fun(messages):
result = _natural_smoother_general(messages, pair_params)
result = result[0][:3], result[1], result[2]
assert shape(result) == shape(dotter)
return contract(dotter, result)
result_py = py_fun(messages)
result_cy = cy_fun(dense_messages)
assert np.isclose(result_py, result_cy)
g_py = grad(py_fun)(messages)
g_cy = unpack_dense_messages(grad(cy_fun)(dense_messages))
assert allclose(g_py, g_cy)
npr.seed(0)
for _ in xrange(50):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_smoother_grads, rand_lds(n, T)
def test_sampler_grads():
def compare_sampler_grads(lds, num_samples, seed):
init_params, pair_params, node_params = lds
messages, _ = natural_filter_forward_general(init_params, pair_params,
node_params)
def fun1(messages):
npr.seed(seed)
samples = natural_sample_backward_general(messages, pair_params,
num_samples)
return np.sum(np.sin(samples))
grads1 = grad(fun1)(messages)
messages, _ = _natural_filter_forward_general(init_params, pair_params,
node_params)
def fun2(messages):
npr.seed(seed)
samples = _natural_sample_backward(messages, pair_params,
num_samples)
return np.sum(np.sin(samples))
grads2 = grad(fun2)(messages)
unpack_dense_grads = lambda x: interleave(*map(lambda y: zip(*y), x))
assert allclose(grads1, unpack_dense_grads(grads2))
npr.seed(0)
for i in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
num_samples = npr.randint(1, 10)
yield compare_sampler_grads, rand_lds(n, T), num_samples, i
def test_sampler_grads():
def compare_sampler_grads(lds, num_samples, seed):
init_params, pair_params, node_params = lds
messages, _ = natural_filter_forward_general(
init_params, pair_params, node_params)
def fun1(messages):
npr.seed(seed)
samples = natural_sample_backward_general(messages, pair_params, num_samples)
return np.sum(np.sin(samples))
grads1 = grad(fun1)(messages)
messages, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
def fun2(messages):
npr.seed(seed)
samples = _natural_sample_backward(messages, pair_params, num_samples)
return np.sum(np.sin(samples))
grads2 = grad(fun2)(messages)
unpack_dense_grads = lambda x: interleave(*map(lambda y: zip(*y), x))
assert allclose(grads1, unpack_dense_grads(grads2))
npr.seed(0)
for i in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
num_samples = npr.randint(1,10)
yield compare_sampler_grads, rand_lds(n, T), num_samples, i
def helper(homog):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10, 50)
lds = rand_lds(n, p, None if homog else T)
states, data = generate_data(T, *lds)
natparam = lds_standard_to_natparam(*lds)
E_stats = natural_lds_Estep(natparam, data)
assert allclose(sub(add(natparam, E_stats), E_stats), natparam)
def test_filter_grad():
def compare_grads(lds):
init_params, pair_params, node_params = lds
dotter = randn_like(natural_filter_forward_general(
init_params, pair_params, node_params)[0])
def messages_to_scalar(messages):
return contract(dotter, messages)
def py_fun(node_params):
messages, lognorm = natural_filter_forward_general(
init_params, pair_params, node_params)
return np.cos(lognorm) + messages_to_scalar(messages)
def cy_fun(node_params):
dense_messages, lognorm = _natural_filter_forward_general(
init_params, pair_params, node_params)
messages = unpack_dense_messages(dense_messages)
return np.cos(lognorm) + messages_to_scalar(messages)
g_py = grad(py_fun)(node_params)
g_cy = grad(cy_fun)(node_params)
assert allclose(g_py, g_cy)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_grads, rand_lds(n, T)
def test_pack_dense():
npr.seed(0)
def check_params(natparam):
natparam2 = pack_dense(*unpack_dense(natparam))
assert np.allclose(natparam, natparam2)
for _ in xrange(5):
n, k = npr.randint(1, 5), npr.randint(1, 3)
yield check_params, rand_natparam(n, k)
def test_param_conversion():
npr.seed(0)
def check_params(natparam):
natparam2 = standard_to_natural(*natural_to_standard(natparam))
assert np.allclose(natparam, natparam2)
for _ in xrange(5):
n, k = npr.randint(1, 5), npr.randint(1, 3)
yield check_params, rand_natparam(n, k)
def test_pack_dense():
npr.seed(0)
def check_params(natparam):
natparam2 = pack_dense(*unpack_dense(natparam))
assert np.allclose(natparam, natparam2)
for _ in xrange(5):
n, k = npr.randint(1, 5), npr.randint(1, 3)
yield check_params, rand_natparam(n, k)
def test_param_conversion():
npr.seed(0)
def check_params(natparam):
natparam2 = standard_to_natural(*natural_to_standard(natparam))
assert np.allclose(natparam, natparam2)
for _ in xrange(5):
n, k = npr.randint(1, 5), npr.randint(1, 3)
yield check_params, rand_natparam(n, k)
def test_expectedstats_autograd():
npr.seed(0)
def check_expectedstats(natparam):
E_stats1 = expectedstats(natparam)
E_stats2 = grad(logZ)(natparam)
assert np.allclose(E_stats1, E_stats2)
for _ in xrange(20):
n, k = npr.randint(1, 5), npr.randint(1, 3)
yield check_expectedstats, rand_natparam(n, k)
def test_lognorm_grad():
def compare_lognorm_grads(hmm):
dotter = npr.randn()
py_grad = grad(lambda x: dotter * python_hmm_logZ(x))(hmm)
cy_grad = grad(lambda x: dotter * cython_hmm_logZ(x))(hmm)
assert allclose(py_grad, cy_grad)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 10), npr.randint(10, 50)
yield compare_lognorm_grads, rand_hmm(n, T)
def test_expectedstats_autograd():
npr.seed(0)
def check_expectedstats(natparam):
E_stats1 = expectedstats(natparam)
E_stats2 = grad(logZ)(natparam)
assert np.allclose(E_stats1, E_stats2)
for _ in xrange(20):
n, k = npr.randint(1, 5), npr.randint(1, 3)
yield check_expectedstats, rand_natparam(n, k)
def test_lognorm_grad():
def compare_lognorm_grads(hmm):
dotter = npr.randn()
py_grad = grad(lambda x: dotter * python_hmm_logZ(x))(hmm)
cy_grad = grad(lambda x: dotter * cython_hmm_logZ(x))(hmm)
assert allclose(py_grad, cy_grad)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 10), npr.randint(10, 50)
yield compare_lognorm_grads, rand_hmm(n, T)
def test_lognorm():
def compare_lognorms(hmm):
py_logZ = python_hmm_logZ(hmm)
cy_logZ = cython_hmm_logZ(hmm)
cy_logZ2 = cython_hmm_logZ_normalized(hmm)[0]
assert np.isclose(py_logZ, cy_logZ)
assert np.isclose(py_logZ, cy_logZ2)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 10), npr.randint(10, 50)
yield compare_lognorms, rand_hmm(n, T)
def test_lognorm():
def compare_lognorms(hmm):
py_logZ = python_hmm_logZ(hmm)
cy_logZ = cython_hmm_logZ(hmm)
cy_logZ2 = cython_hmm_logZ_normalized(hmm)[0]
assert np.isclose(py_logZ, cy_logZ)
assert np.isclose(py_logZ, cy_logZ2)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 10), npr.randint(10, 50)
yield compare_lognorms, rand_hmm(n, T)
def test_multivariate_normal_logpdf_shared_params(D=10):
# Test broadcasting over datapoints with shared parameters
leading_ndim = npr.randint(1, 4)
shp = npr.randint(1, 10, size=leading_ndim)
x = npr.randn(*shp, D)
mu = npr.randn(D)
L = npr.randn(D, D)
Sigma = np.dot(L, L.T)
ll1 = multivariate_normal_logpdf(x, mu, Sigma)
ll2 = np.reshape(mvn.logpdf(x, mu, Sigma), shp)
assert np.allclose(ll1, ll2)
def test_multivariate_normal_logpdf_unique_params(D=10):
# Test broadcasting over datapoints and corresponding parameters
leading_ndim = npr.randint(1, 4)
shp = npr.randint(1, 10, size=leading_ndim)
x = npr.randn(*shp, D)
mu = npr.randn(*shp, D)
L = npr.randn(*shp, D, D)
Sigma = np.matmul(L, np.swapaxes(L, -1, -2))
ll1 = multivariate_normal_logpdf(x, mu, Sigma)
ll2 = np.empty(shp)
for inds in product(*[np.arange(s) for s in shp]):
ll2[inds] = mvn.logpdf(x[inds], mu[inds], Sigma[inds])
assert np.allclose(ll1, ll2)
def test_filters():
def compare_filters(lds):
init_params, pair_params, node_params = lds
messages1, lognorm1 = natural_filter_forward_general(
init_params, pair_params, node_params)
dense_messages2, lognorm2 = _natural_filter_forward_general(
init_params, pair_params, node_params)
messages2 = unpack_dense_messages(dense_messages2)
assert allclose(messages1, messages2)
assert np.isclose(lognorm1, lognorm2)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_filters, rand_lds(n, T)
def test_trace_extradims():
def fun(x): return to_scalar(np.trace(x, offset=offset))
d_fun = lambda x : to_scalar(grad(fun)(x))
mat = npr.randn(5,6,4,3)
offset = npr.randint(-5,6)
check_grads(fun, mat)
check_grads(d_fun, mat)
def test_trace2():
def fun(x): return np.trace(x, offset=offset)
d_fun = lambda x : to_scalar(grad(fun)(x))
mat = npr.randn(11, 10)
offset = npr.randint(-9,11)
check_grads(fun, mat)
check_grads(d_fun, mat)
def test_trace2():
def fun(x): return np.trace(x, offset=offset)
d_fun = lambda x : to_scalar(grad(fun)(x))
mat = npr.randn(11, 10)
offset = npr.randint(-9,11)
check_grads(fun, mat)
check_grads(d_fun, mat)
def test_E_step_inhomog():
def compare_E_step(lds, data):
natparam = lds_standard_to_natparam(*lds)
E_init_stats, E_pairwise_stats, E_node_stats = natural_lds_Estep(natparam, data)
E_init_stats2, E_pairwise_stats2, E_node_stats2 = pylds_E_step_inhomog(lds, data)
assert all(map(np.allclose, E_init_stats, E_init_stats2))
assert all(map(np.allclose, E_pairwise_stats, E_pairwise_stats2))
assert all(map(np.allclose, E_node_stats, E_node_stats2))
for _ in xrange(10):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10,50)
lds = rand_lds(n, p, T)
states, data = generate_data(T, *lds)
yield compare_E_step, lds, data
def test_trace_extradims():
def fun(x): return to_scalar(np.trace(x, offset=offset))
d_fun = lambda x : to_scalar(grad(fun)(x))
mat = npr.randn(5,6,4,3)
offset = npr.randint(-5,6)
check_grads(fun, mat)
check_grads(d_fun, mat)
def test_trace_extradims():
def fun(x):
return np.trace(x, offset=offset)
mat = npr.randn(5, 6, 4, 3)
offset = npr.randint(-5, 6)
check_grads(fun)(mat)
def test_trace2():
def fun(x):
return np.trace(x, offset=offset)
mat = npr.randn(11, 10)
offset = npr.randint(-9, 11)
check_grads(fun)(mat)
def test_filters():
def compare_filters(lds):
init_params, pair_params, node_params = lds
messages1, lognorm1 = natural_filter_forward_general(
init_params, pair_params, node_params)
dense_messages2, lognorm2 = _natural_filter_forward_general(
init_params, pair_params, node_params)
messages2 = unpack_dense_messages(dense_messages2)
assert allclose(messages1, messages2)
assert np.isclose(lognorm1, lognorm2)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_filters, rand_lds(n, T)
def testEinsumRepeatedOneHot(self):
x = npr.randn(3, 2)
y = npr.randn(3, 2)
e = npr.randint(0, x.shape[0], 5)
def fun(x, y, e):
one_hot_e = tracers.one_hot(e, x.shape[0])
return np.einsum('ab,bc,ad,dc->', one_hot_e, x, one_hot_e, y)
expr = self._rewriter_test_helper(fun,
rewrites.einsum_repeated_one_hot, x,
y, e)
self.assertEqual(len(expr.expr_node.args), 4)
self.assertEqual(
sum(node.fun == tracers.one_hot
for node in expr.expr_node.parents), 1)
def fun(x, y, e):
one_hot_e = tracers.one_hot(e, x.shape[0])
return np.einsum('ab,bc,ad,dc->ac', one_hot_e, x, one_hot_e, y)
expr = self._rewriter_test_helper(fun,
rewrites.einsum_repeated_one_hot, x,
y, e)
self.assertEqual(len(expr.expr_node.args), 4)
self.assertEqual(
sum(node.fun == tracers.one_hot
for node in expr.expr_node.parents), 1)
def objective_grad_and_log_norm(var_param):
seed = npr.randint(2**32)
log_weights = compute_log_weights(var_param, seed)
log_norm = np.max(log_weights)
scaled_values = np.exp(log_weights - log_norm)**alpha
obj_value = np.log(np.mean(scaled_values))/alpha + log_norm
obj_grad = alpha*log_weights_vjp(var_param, seed, scaled_values) / scaled_values.size
return (obj_value, obj_grad)
def test_filters():
def compare_filters(lds, data):
(filtered_mus, filtered_sigmas), loglike = filter_forward(data, *lds)
messages, lognorm = natural_filter_forward(lds_standard_to_natparam(*lds), data)
prediction_messages, filter_messages = uninterleave(messages)
natural_filtered_mus, natural_filtered_sigmas = zip(*map(natural_to_mean, filter_messages))
assert all(map(np.allclose, filtered_mus, natural_filtered_mus))
assert all(map(np.allclose, filtered_sigmas, natural_filtered_sigmas))
assert np.isclose(loglike, lognorm)
for _ in xrange(10):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10,50)
lds = rand_lds(n, p)
states, data = generate_data(T, *lds)
yield compare_filters, lds, data
def generate_tagging_set(self, Xtr, size=20):
indices = []
for i in range(size):
index = npr.randint(0, len(Xtr))
if index in indices:
continue
indices.append(index)
image = self.get_image(Xtr[index], index)
image.save('tagging/decoy_mnist/' + str(index) + '.png')
def test_E_step_inhomog():
def compare_E_step(lds, data):
natparam = lds_standard_to_natparam(*lds)
E_init_stats, E_pairwise_stats, E_node_stats = natural_lds_Estep(
natparam, data)
E_init_stats2, E_pairwise_stats2, E_node_stats2 = pylds_E_step_inhomog(
lds, data)
assert all(map(np.allclose, E_init_stats, E_init_stats2))
assert all(map(np.allclose, E_pairwise_stats, E_pairwise_stats2))
assert all(map(np.allclose, E_node_stats, E_node_stats2))
for _ in xrange(10):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10, 50)
lds = rand_lds(n, p, T)
states, data = generate_data(T, *lds)
yield compare_E_step, lds, data
def sample(self, total_steps=0):
"""Sample from the experience buffer by rank prioritization if specified.
Otherwise sampling is done uniformly.
Keyword arguments:
total_steps -- number of steps taken in experiment (default: 0)
"""
N = self.size
num_samples = np.min(
(self.batch_size * self.num_strata_samples, self.size))
# Perform uniform sampling of experience buffer
if not self.mem_priority:
indices = npr.choice(range(N), replace=False, size=num_samples)
exp_batch = np.array(self.exp_buffer)[indices]
weights = np.ones(len(indices)) / (len(indices) * 1.0)
return np.reshape(exp_batch, (num_samples, -1)), weights, indices
# Perform prioritized sampling of experience buffer
else:
# Find the closest precomptued distribution by size
dist_idx = math.floor(N / float(self.capacity) *
self.num_partitions)
distribution = self.distributions[int(dist_idx)]
N = dist_idx * 100
rank_indices_set = set()
# Perform stratified sampling of priority queue
for i_exp in range(num_samples)[::-1]:
# To increase the training batch size we sample several times from each strata, repeated indices are eliminated
rank_indices_set.add(
npr.randint(
distribution['strata_ends'][i_exp /
self.num_strata_samples],
distribution['strata_ends'][(i_exp /
self.num_strata_samples) +
1]))
rank_indices = list(rank_indices_set)
exp_indices = self.pq.get_values_by_val(rank_indices)
exp_batch = [
self.exp_buffer[int(exp_idx)] for exp_idx in exp_indices
]
# Compute importance sampling weights
beta = np.min([
self.beta_zero +
(total_steps - self.num_init_train - 1) * self.beta_grad, 1
])
IS_weights = np.power(N * distribution['pdf'][rank_indices],
-1 * beta)
# Normalize IS_weights by maximum weight, guarantees that IS weights only scale downwards
w_max = np.max(IS_weights)
IS_weights = IS_weights / float(w_max)
return np.reshape(exp_batch,
(len(exp_indices), -1)), IS_weights, exp_indices
def test_filters():
def compare_filters(lds, data):
(filtered_mus, filtered_sigmas), loglike = filter_forward(data, *lds)
messages, lognorm = natural_filter_forward(
lds_standard_to_natparam(*lds), data)
prediction_messages, filter_messages = uninterleave(messages)
natural_filtered_mus, natural_filtered_sigmas = zip(
*map(natural_to_mean, filter_messages))
assert all(map(np.allclose, filtered_mus, natural_filtered_mus))
assert all(map(np.allclose, filtered_sigmas, natural_filtered_sigmas))
assert np.isclose(loglike, lognorm)
for _ in xrange(10):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10, 50)
lds = rand_lds(n, p)
states, data = generate_data(T, *lds)
yield compare_filters, lds, data
def test_samplers():
def compare_samplers(lds, num_samples, seed):
init_params, pair_params, node_params = lds
npr.seed(seed)
messages1, _ = natural_filter_forward_general(
init_params, pair_params, node_params)
samples1 = natural_sample_backward_general(messages1, pair_params, num_samples)
npr.seed(seed)
dense_messages2, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
samples2 = _natural_sample_backward(dense_messages2, pair_params, num_samples)
assert np.allclose(samples1, samples2)
npr.seed(0)
for i in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
num_samples = npr.randint(1,10)
yield compare_samplers, rand_lds(n, T), num_samples, i
def test_smoothers():
def compare_smoothers(lds):
init_params, pair_params, node_params = lds
messages1, _ = natural_filter_forward_general(
init_params, pair_params, node_params)
E_init_stats1, E_pair_stats1, E_node_stats1 = \
natural_smoother_general(messages1, *lds)
dense_messages2, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
E_init_stats2, E_pair_stats2, E_node_stats2 = \
_natural_smoother_general(dense_messages2, pair_params)
assert allclose(E_init_stats1[:3], E_init_stats2[:3])
assert allclose(E_pair_stats1, E_pair_stats2)
assert allclose(E_node_stats1, E_node_stats2)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_smoothers, rand_lds(n, T)
def test_smoothers():
def compare_smoothers(lds):
init_params, pair_params, node_params = lds
messages1, _ = natural_filter_forward_general(init_params, pair_params,
node_params)
E_init_stats1, E_pair_stats1, E_node_stats1 = \
natural_smoother_general(messages1, *lds)
dense_messages2, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
E_init_stats2, E_pair_stats2, E_node_stats2 = \
_natural_smoother_general(dense_messages2, pair_params)
assert allclose(E_init_stats1[:3], E_init_stats2[:3])
assert allclose(E_pair_stats1, E_pair_stats2)
assert allclose(E_node_stats1, E_node_stats2)
npr.seed(0)
for _ in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_smoothers, rand_lds(n, T)
def test_general_inference():
def get_general_node_params(x, lds):
T, p = x.shape
C, sigma_obs = lds[-2:]
J, Jzx, Jxx, logZ = pair_mean_to_natural(C, sigma_obs)
h = np.einsum('tzx,tx->tz', Jzx, x)
logZ += np.einsum('ti,tij,tj->t', x, Jxx,
x) - p / 2. * np.log(2 * np.pi)
return J, h, logZ
def compare_E_step(lds, data):
natparam = init_params, pair_params, node_params = lds_standard_to_natparam(
*lds)
general_node_params = get_general_node_params(data, lds)
C, sigma_obs = lds[-2:]
sample, E_stats, lognorm = natural_lds_inference(natparam, data)
sample2, E_stats2, lognorm2 = natural_lds_inference_general(
(init_params, pair_params), general_node_params)
sample3, E_stats3, lognorm3 = natural_lds_inference_general_nosaving(
(init_params, pair_params), general_node_params)
sample4, E_stats4, lognorm4 = natural_lds_inference_general_autograd(
(init_params, pair_params), general_node_params)
assert allclose(E_stats[:-1], E_stats2[:-1])
assert allclose(E_stats2, E_stats3)
assert allclose(E_stats2, E_stats4)
assert np.isclose(lognorm, lognorm2)
assert np.isclose(lognorm, lognorm3)
assert np.isclose(lognorm, lognorm4)
for _ in xrange(10):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10, 50)
lds = rand_lds(n, p, T)
states, data = generate_data(T, *lds)
yield compare_E_step, lds, data
def test_samplers():
def compare_samplers(lds, num_samples, seed):
init_params, pair_params, node_params = lds
npr.seed(seed)
messages1, _ = natural_filter_forward_general(init_params, pair_params,
node_params)
samples1 = natural_sample_backward_general(messages1, pair_params,
num_samples)
npr.seed(seed)
dense_messages2, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
samples2 = _natural_sample_backward(dense_messages2, pair_params,
num_samples)
assert np.allclose(samples1, samples2)
npr.seed(0)
for i in xrange(25):
n, T = npr.randint(1, 5), npr.randint(10, 50)
num_samples = npr.randint(1, 10)
yield compare_samplers, rand_lds(n, T), num_samples, i
def test_smoother_grads():
def compare_smoother_grads(lds):
init_params, pair_params, node_params = lds
symmetrize = make_unop(
lambda x: (x + x.T) / 2. if np.ndim(x) == 2 else x, tuple)
messages, _ = natural_filter_forward_general(*lds)
dotter = randn_like(natural_smoother_general(messages, *lds))
def py_fun(messages):
result = natural_smoother_general(messages, *lds)
assert shape(result) == shape(dotter)
return contract(dotter, result)
dense_messages, _ = _natural_filter_forward_general(
init_params, pair_params, node_params)
def cy_fun(messages):
result = _natural_smoother_general(messages, pair_params)
result = result[0][:3], result[1], result[2]
assert shape(result) == shape(dotter)
return contract(dotter, result)
result_py = py_fun(messages)
result_cy = cy_fun(dense_messages)
assert np.isclose(result_py, result_cy)
g_py = grad(py_fun)(messages)
g_cy = unpack_dense_messages(grad(cy_fun)(dense_messages))
assert allclose(g_py, g_cy)
npr.seed(0)
for _ in xrange(50):
n, T = npr.randint(1, 5), npr.randint(10, 50)
yield compare_smoother_grads, rand_lds(n, T)
def test_categorical_logpdf(T=100, K=4, D=10, C=8):
# Test single datapoint log pdf
x = npr.randint(0, C, size=(T, D))
logits = npr.randn(K, D, C)
logits -= logsumexp(logits, axis=-1, keepdims=True)
ps = np.exp(logits)
log_ps = np.log(ps)
ll1 = categorical_logpdf(x[:, None, :], logits)
ll2 = np.zeros((T, K))
for n in range(T):
for k in range(K):
for d in range(D):
ll2[n, k] += log_ps[k, d, x[n, d]]
assert np.allclose(ll1, ll2)
def test_general_inference():
def get_general_node_params(x, lds):
T, p = x.shape
C, sigma_obs = lds[-2:]
J, Jzx, Jxx, logZ = pair_mean_to_natural(C, sigma_obs)
h = np.einsum('tzx,tx->tz', Jzx, x)
logZ += np.einsum('ti,tij,tj->t', x, Jxx, x) - p/2.*np.log(2*np.pi)
return J, h, logZ
def compare_E_step(lds, data):
natparam = init_params, pair_params, node_params = lds_standard_to_natparam(*lds)
general_node_params = get_general_node_params(data, lds)
C, sigma_obs = lds[-2:]
sample, E_stats, lognorm = natural_lds_inference(natparam, data)
sample2, E_stats2, lognorm2 = natural_lds_inference_general(
(init_params, pair_params), general_node_params)
sample3, E_stats3, lognorm3 = natural_lds_inference_general_nosaving(
(init_params, pair_params), general_node_params)
sample4, E_stats4, lognorm4 = natural_lds_inference_general_autograd(
(init_params, pair_params), general_node_params)
assert allclose(E_stats[:-1], E_stats2[:-1])
assert allclose(E_stats2, E_stats3)
assert allclose(E_stats2, E_stats4)
assert np.isclose(lognorm, lognorm2)
assert np.isclose(lognorm, lognorm3)
assert np.isclose(lognorm, lognorm4)
for _ in xrange(10):
n, p, T = npr.randint(1, 5), npr.randint(1, 5), npr.randint(10,50)
lds = rand_lds(n, p, T)
states, data = generate_data(T, *lds)
yield compare_E_step, lds, data
def __init__(self, K, D, M=0):
super(NegativeBinomialSemiMarkovTransitions, self).__init__(K, D, M=M)
# Initialize the super state transition probabilities
self.Ps = npr.rand(K, K)
np.fill_diagonal(self.Ps, 0)
self.Ps /= self.Ps.sum(axis=1, keepdims=True)
# Initialize the negative binomial duration probabilities
self.rs = npr.randint(1, 11, size=K)
# self.rs = np.ones(K, dtype=int)
# self.ps = npr.rand(K)
self.ps = 0.5 * np.ones(K)
# Initialize the transition matrix
self._trans_matrix = None
def __init__(self, K, D, M=0, r_min=1, r_max=20):
assert K > 1, "Explicit duration models only work if num states > 1."
super(NegativeBinomialSemiMarkovTransitions, self).__init__(K, D, M=M)
# Initialize the super state transition probabilities
self.Ps = npr.rand(K, K)
np.fill_diagonal(self.Ps, 0)
self.Ps /= self.Ps.sum(axis=1, keepdims=True)
# Initialize the negative binomial duration probabilities
self.r_min, self.r_max = r_min, r_max
self.rs = npr.randint(r_min, r_max + 1, size=K)
# self.rs = np.ones(K, dtype=int)
# self.ps = npr.rand(K)
self.ps = 0.5 * np.ones(K)
# Initialize the transition matrix
self._transition_matrix = None
# Initialize variational parameters
rs = npr.RandomState(0)
num_samples = 5
init_mean = rs.randn(num_weights)
init_log_std = -5 * np.ones(num_weights)
variational_params = np.concatenate([init_mean, init_log_std])
# Set up figure.
fig = plt.figure(figsize=(8,8), facecolor='white')
ax = fig.add_subplot(111, frameon=False)
plt.ion()
plt.show(block=False)
for step in range(num_steps):
# Grab a random datum
datum_id = npr.randint(0, num_datums)
# Assess expected reward across all possible actions (loop over context + action vectors)
rewards = []
contexts = np.zeros((num_actions, F))
for aa in range(num_actions):
contexts[aa,:] = np.hstack((x[datum_id, :], [aa]))
outputs = generate_nn_output(variational_params,
np.expand_dims(contexts[aa,:],0),
num_weights,
num_samples)
rewards.append(np.mean(outputs))
# Check which is greater and choose that [1,0] = eat | [0,1] do not eat
# If argmax returns 0, then we eat, otherwise we don't
action_chosen = np.argmax(rewards)
def int_series(center, spread):
return npr.randint(center - spread,
high=center + spread + 1,
size=count)
* np.array([radial_std, tangential_std])
features[:, 0] += 1.
labels = np.repeat(np.arange(num_classes), num_per_class)
angles = rads[labels] + rate * np.exp(features[:, 0])
rotations = np.stack(
[np.cos(angles), -np.sin(angles),
np.sin(angles),
np.cos(angles)])
rotations = np.reshape(rotations.T, (-1, 2, 2))
return 10 * npr.permutation(np.einsum('ti,tij->tj', features, rotations))
if __name__ == "__main__":
seed_no = npr.randint(1000)
print(seed_no)
npr.seed(seed_no)
#plt.ion()
num_clusters = 5 # number of clusters in pinwheel data
samples_per_cluster = 100 # number of samples per cluster in pinwheel
T = 50 # Truncation level for number of components
N = 2 # number of latent dimensions
P = 2 # number of observation dimensions
alpha = 1000 # scale parameter for DP
niw_conc = 0.5 # concentration parameter for NIW prior
# generate synthetic data
#data = make_pinwheel_data(0.3, 0.05, num_clusters, samples_per_cluster, 0.25)
filename = '/Users/ybansal/Documents/PhD/Courses/CS282/Project/Code/Data/xor.hkl'
def randn(self):
# These arbitrary vectors are not analogous to randn in any meaningful way
N = npr.randint(1,3)
return RKHSFun(self.kernel, dict(zip(npr.randn(N), npr.randn(N))))
