def test_tt_to_tensor_random():
""" Test for tt_to_tensor
Uses random tensor as input
"""
# Create tensor with random elements
tensor = tl.tensor(np.random.rand(3, 4, 5, 6, 2, 10))
tensor_shape = tensor.shape
# Find TT decomposition of the tensor
rank = 10
factors = tensor_train(tensor, rank)
# Reconstruct the original tensor
reconstructed_tensor = tl.tt_to_tensor(factors)
assert_(tl.shape(reconstructed_tensor) == tensor_shape)
# Check that the rank is 10
D = len(factors)
for k in range(D):
(r_prev, _, r_k) = factors[k].shape
assert (r_prev <=
rank), "TT rank with index " + str(k) + "exceeds rank"
assert (r_k <=
rank), "TT rank with index " + str(k + 1) + "exceeds rank"
def test_tensor_train():
""" Test for tensor_train """
rng = tl.check_random_state(1234)
## Test 1
# Create tensor with random elements
tensor = tl.tensor(rng.random_sample([3, 4, 5, 6, 2, 10]))
tensor_shape = tensor.shape
# Find TT decomposition of the tensor
rank = [1, 3, 3, 4, 2, 2, 1]
factors = tensor_train(tensor, rank)
assert (
len(factors) == 6
), "Number of factors should be 6, currently has " + str(len(factors))
# Check that the ranks are correct and that the second mode of each factor
# has the correct number of elements
r_prev_iteration = 1
for k in range(6):
(r_prev_k, n_k, r_k) = factors[k].shape
assert (tensor_shape[k] == n_k
), "Mode 1 of factor " + str(k) + "needs " + str(
tensor_shape[k]) + " dimensions, currently has " + str(n_k)
assert (r_prev_k == r_prev_iteration), " Incorrect ranks of factors "
r_prev_iteration = r_k
## Test 2
# Create tensor with random elements
tensor = tl.tensor(rng.random_sample([3, 4, 5, 6, 2, 10]))
tensor_shape = tensor.shape
# Find TT decomposition of the tensor
rank = [1, 5, 4, 3, 8, 10, 1]
factors = tensor_train(tensor, rank)
for k in range(6):
(r_prev, n_k, r_k) = factors[k].shape
first_error_message = "TT rank " + str(
k) + " is greater than the maximum allowed "
first_error_message += str(r_prev) + " > " + str(rank[k])
assert (r_prev <= rank[k]), first_error_message
first_error_message = "TT rank " + str(
k + 1) + " is greater than the maximum allowed "
first_error_message += str(r_k) + " > " + str(rank[k + 1])
assert (r_k <= rank[k + 1]), first_error_message
## Test 3
tol = 10e-5
tensor = tl.tensor(rng.random_sample([3, 3, 3]))
factors = tensor_train(tensor, (1, 3, 3, 1))
reconstructed_tensor = tl.tt_to_tensor(factors)
error = tl.norm(reconstructed_tensor - tensor, 2)
error /= tl.norm(tensor, 2)
assert_(error < tol, 'norm 2 of reconstruction higher than tol')
def test_tt_to_tensor():
""" Test for tt_to_tensor
References
----------
.. [1] Anton Rodomanov. "Introduction to the Tensor Train Decomposition
and Its Applications in Machine Learning", HSE Seminar on Applied
Linear Algebra, Moscow, Russia, March 2016.
"""
# Create tensor
n1 = 3
n2 = 4
n3 = 2
tensor = np.zeros((n1, n2, n3))
for i in range(n1):
for j in range(n2):
for k in range(n3):
tensor[i][j][k] = (i+1) + (j+1) + (k+1)
tensor = tl.tensor(tensor)
# Compute ground truth TT factors
factors = [None] * 3
factors[0] = np.zeros((1, 3, 2))
factors[1] = np.zeros((2, 4, 2))
factors[2] = np.zeros((2, 2, 1))
for i in range(3):
for j in range(4):
for k in range(2):
factors[0][0][i][0] = i+1
factors[0][0][i][1] = 1
factors[1][0][j][0] = 1
factors[1][0][j][1] = 0
factors[1][1][j][0] = j+1
factors[1][1][j][1] = 1
factors[2][0][k][0] = 1
factors[2][1][k][0] = k+1
factors = [tl.tensor(f) for f in factors]
# Check that TT factors re-assemble to the original tensor
assert_array_almost_equal(tensor, tl.tt_to_tensor(factors))
def to_tensor(self):
return tl.tt_to_tensor(self.decomposition)
