def _get_mu(self, ranks, x, y):
"""Initializes latent inputs expectations mu.
Either loads pretrained values of tt-cores of mu, or initializes it
according to optimal formulas from the given data.
Args:
ranks: tt-ranks of mu
x: features of a batch of objects
y: targets of a batch of objects
"""
# TODO: test if this is needed.
w = self.inputs.interpolate_on_batch(self.cov.project(x))
Sigma = ops.tt_tt_matmul(self.sigma_l, ops.transpose(self.sigma_l))
temp = ops.tt_tt_matmul(w, y)
anc = ops.tt_tt_matmul(Sigma, temp)
res = TensorTrain([core[0, :, :, :, :] for core in anc.tt_cores],
tt_ranks=[1]*(anc.ndims()+1))
res = res
for i in range(1, anc.get_shape()[0]):
elem = TensorTrain([core[i, :, :, :, :] for core in anc.tt_cores],
tt_ranks=[1]*(anc.ndims()+1))
res = ops.add(res, elem)
mu_ranks = [1] + [ranks] * (res.ndims() - 1) + [1]
return t3f.get_variable('tt_mu', initializer=TensorTrain(res.tt_cores,
res.get_raw_shape(), mu_ranks))
def __add__(self, other):
"""Returns a TensorTrain corresponding to element-wise sum tt_a + tt_b.
Supports broadcasting (e.g. you can add TensorTrainBatch and TensorTrain).
Just calls t3f.add, see its documentation for details.
"""
# TODO: ugly.
# We can't import ops in the beginning since it creates cyclic dependencies.
from t3f import ops
return ops.add(self, other)
def __sub__(self, other):
"""Returns a TensorTrain corresponding to element-wise difference tt_a - tt_b.
Supports broadcasting (e.g. you can subtract TensorTrainBatch and
TensorTrain).
Just calls t3f.add(self, (-1) * other), see its documentation for details.
"""
# TODO: ugly.
# We can't import ops in the beginning since it creates cyclic dependencies.
from t3f import ops
return ops.add(self, ops.multiply(other, -1.))
def testAdd(self):
# Sum two TT-tensors.
tt_a = initializers.random_tensor((2, 1, 3, 4), tt_rank=2)
tt_b = initializers.random_tensor((2, 1, 3, 4),
tt_rank=[1, 2, 4, 3, 1])
with self.test_session() as sess:
res_actual = ops.full(ops.add(tt_a, tt_b))
res_actual2 = ops.full(tt_a + tt_b)
res_desired = ops.full(tt_a) + ops.full(tt_b)
to_run = [res_actual, res_actual2, res_desired]
res_actual_val, res_actual2_val, res_desired_val = sess.run(to_run)
self.assertAllClose(res_actual_val, res_desired_val)
self.assertAllClose(res_actual2_val, res_desired_val)
def testAddBroadcasting(self):
# Sum two TT-tensors with broadcasting.
tt_a = initializers.random_tensor_batch((2, 1, 4), tt_rank=2, batch_size=1,
dtype=self.dtype)
tt_b = initializers.random_tensor_batch((2, 1, 4), tt_rank=[1, 2, 4, 1],
batch_size=3, dtype=self.dtype)
with self.test_session() as sess:
res_actual = ops.full(ops.add(tt_a, tt_b))
res_actual2 = ops.full(tt_b + tt_a)
res_desired = ops.full(tt_a) + ops.full(tt_b)
to_run = [res_actual, res_actual2, res_desired]
res_actual_val, res_actual2_val, res_desired_val = sess.run(to_run)
self.assertAllClose(res_actual_val, res_desired_val)
self.assertAllClose(res_actual2_val, res_desired_val)
def testAddSameBatchSize(self):
# Sum two TT-matrices with the same batch size.
tt_a = initializers.random_matrix_batch(((2, 1, 4), None), tt_rank=2,
batch_size=3, dtype=self.dtype)
tt_b = initializers.random_matrix_batch(((2, 1, 4), None),
tt_rank=[1, 2, 4, 1], batch_size=3,
dtype=self.dtype)
with self.test_session() as sess:
res_actual = ops.full(ops.add(tt_a, tt_b))
res_actual2 = ops.full(tt_a + tt_b)
res_desired = ops.full(tt_a) + ops.full(tt_b)
to_run = [res_actual, res_actual2, res_desired]
res_actual_val, res_actual2_val, res_desired_val = sess.run(to_run)
self.assertAllClose(res_actual_val, res_desired_val)
self.assertAllClose(res_actual2_val, res_desired_val)
def testAdd(self):
# Sum two TT-tensors.
tt_a = initializers.random_tensor((2, 1, 3, 4),
tt_rank=2,
dtype=self.dtype)
tt_b = initializers.random_tensor((2, 1, 3, 4),
tt_rank=[1, 2, 4, 3, 1],
dtype=self.dtype)
res_actual = ops.full(ops.add(tt_a, tt_b))
res_actual2 = ops.full(tt_a + tt_b)
res_desired = ops.full(tt_a) + ops.full(tt_b)
to_run = [res_actual, res_actual2, res_desired]
res_actual_val, res_actual2_val, res_desired_val = self.evaluate(
to_run)
self.assertAllClose(res_actual_val, res_desired_val)
self.assertAllClose(res_actual2_val, res_desired_val)
def _get_mus(self, ranks, x_init, y_init):
w = self.inputs.interpolate_on_batch(self.cov.project(x_init))
Sigma = ops.tt_tt_matmul(self.sigma_ls[0], ops.transpose(self.sigma_ls[0]))
temp = ops.tt_tt_matmul(w, y_init)
anc = ops.tt_tt_matmul(Sigma, temp)
res = TensorTrain([core[0, :, :, :, :] for core in anc.tt_cores],
tt_ranks=[1]*(anc.ndims()+1))
res = res
for i in range(1, anc.get_shape()[0]):
elem = TensorTrain([core[i, :, :, :, :] for core in anc.tt_cores],
tt_ranks=[1]*(anc.ndims()+1))
res = ops.add(res, elem)
mu_ranks = [1] + [ranks] * (res.ndims() - 1) + [1]
mu_cores = []
for core in res.tt_cores:
mu_cores.append(tf.tile(core[None, ...], [self.n_class, 1, 1, 1, 1]))
return t3f.get_variable('tt_mus',
initializer=TensorTrainBatch(mu_cores, res.get_raw_shape(), mu_ranks))
def testAddBroadcasting(self):
# Sum two TT-matrices with broadcasting.
tt_a = initializers.random_matrix_batch(((2, 1, 4), (2, 2, 2)),
tt_rank=2,
batch_size=3,
dtype=self.dtype)
tt_b = initializers.random_matrix_batch(((2, 1, 4), (2, 2, 2)),
tt_rank=[1, 2, 4, 1],
batch_size=1,
dtype=self.dtype)
res_actual = ops.full(ops.add(tt_a, tt_b))
res_actual2 = ops.full(tt_b + tt_a)
res_desired = ops.full(tt_a) + ops.full(tt_b)
to_run = [res_actual, res_actual2, res_desired]
res_actual_val, res_actual2_val, res_desired_val = self.evaluate(
to_run)
self.assertAllClose(res_actual_val, res_desired_val)
self.assertAllClose(res_actual2_val, res_desired_val)
def testAddSameBatchSize(self):
# Sum two TT-tensors with the same batch size.
tt_a = initializers.random_tensor_batch((2, 1, 4),
tt_rank=2,
batch_size=3,
dtype=self.dtype)
tt_b = initializers.random_tensor_batch((2, 1, 4),
tt_rank=[1, 2, 4, 1],
batch_size=3,
dtype=self.dtype)
res_actual = ops.full(ops.add(tt_a, tt_b))
res_actual2 = ops.full(tt_a + tt_b)
res_desired = ops.full(tt_a) + ops.full(tt_b)
to_run = [res_actual, res_actual2, res_desired]
res_actual_val, res_actual2_val, res_desired_val = self.evaluate(
to_run)
self.assertAllClose(res_actual_val, res_desired_val)
self.assertAllClose(res_actual2_val, res_desired_val)