def test_kruskal_to_tensor_with_weights():
A = tl.reshape(tl.arange(1, 5), (2, 2))
B = tl.reshape(tl.arange(5, 9), (2, 2))
weights = tl.tensor([2, -1])
out = kruskal_to_tensor((weights, [A, B]))
expected = tl.tensor([[-2, -2], [6, 10]]) # computed by hand
assert_array_equal(out, expected)
def test_cp_to_tensor():
"""Test for cp_to_tensor."""
U1 = np.reshape(np.arange(1, 10), (3, 3))
U2 = np.reshape(np.arange(10, 22), (4, 3))
U3 = np.reshape(np.arange(22, 28), (2, 3))
U4 = np.reshape(np.arange(28, 34), (2, 3))
U = [tl.tensor(t) for t in [U1, U2, U3, U4]]
true_res = tl.tensor([[[[ 46754., 51524.],
[ 52748., 58130.]],
[[ 59084., 65114.],
[ 66662., 73466.]],
[[ 71414., 78704.],
[ 80576., 88802.]],
[[ 83744., 92294.],
[ 94490., 104138.]]],
[[[ 113165., 124784.],
[ 127790., 140912.]],
[[ 143522., 158264.],
[ 162080., 178730.]],
[[ 173879., 191744.],
[ 196370., 216548.]],
[[ 204236., 225224.],
[ 230660., 254366.]]],
[[[ 179576., 198044.],
[ 202832., 223694.]],
[[ 227960., 251414.],
[ 257498., 283994.]],
[[ 276344., 304784.],
[ 312164., 344294.]],
[[ 324728., 358154.],
[ 366830., 404594.]]]])
res = cp_to_tensor((tl.ones(3), U))
assert_array_equal(res, true_res, err_msg='Khatri-rao incorrectly transformed into full tensor.')
columns = 4
rows = [3, 4, 2]
matrices = [tl.tensor(np.arange(k * columns).reshape((k, columns))) for k in rows]
tensor = cp_to_tensor((tl.ones(columns), matrices))
for i in range(len(rows)):
unfolded = unfold(tensor, mode=i)
U_i = matrices.pop(i)
reconstructed = tl.dot(U_i, tl.transpose(khatri_rao(matrices)))
assert_array_almost_equal(reconstructed, unfolded)
matrices.insert(i, U_i)
def test_cp_flip_sign():
shape = (3, 4, 5)
rank = 4
cp_tensor = random_cp(shape, rank)
weights, factors = cp_flip_sign(cp_tensor)
assert_(tl.all(tl.mean(factors[1], axis=0) > 0))
assert_(tl.all(tl.mean(factors[2], axis=0) > 0))
assert_equal(cp_tensor.rank, cp_tensor.rank)
assert_array_equal(cp_tensor.weights, weights)
assert_array_almost_equal(cp_to_tensor((weights, factors)), cp_to_tensor(cp_tensor))
def test_cp_to_vec():
"""Test for cp_to_vec"""
U1 = np.reshape(np.arange(1, 10), (3, 3))
U2 = np.reshape(np.arange(10, 22), (4, 3))
U3 = np.reshape(np.arange(22, 28), (2, 3))
U4 = np.reshape(np.arange(28, 34), (2, 3))
U = [tl.tensor(t) for t in [U1, U2, U3, U4]]
cp_tensor = CPTensor((tl.ones(3), U))
full_tensor = cp_to_tensor(cp_tensor)
true_res = tensor_to_vec(full_tensor)
res = cp_to_vec(cp_tensor)
assert_array_equal(true_res, res, err_msg='khatri_rao product converted incorrectly to vec.')
def test_cp_to_unfolded():
"""Test for cp_to_unfolded.
!!Assumes that cp_to_tensor and unfold are properly tested and work!!
"""
U1 = np.reshape(np.arange(1, 10), (3, 3))
U2 = np.reshape(np.arange(10, 22), (4, 3))
U3 = np.reshape(np.arange(22, 28), (2, 3))
U4 = np.reshape(np.arange(28, 34), (2, 3))
U = [tl.tensor(t) for t in [U1, U2, U3, U4]]
cp_tensor = CPTensor((tl.ones(3), U))
full_tensor = cp_to_tensor(cp_tensor)
for mode in range(4):
true_res = unfold(full_tensor, mode)
res = cp_to_unfolded(cp_tensor, mode)
assert_array_equal(true_res, res, err_msg='khatri_rao product unfolded incorrectly for mode {}.'.format(mode))
def test_cp_to_tensor_with_weights():
A = tl.reshape(tl.arange(1,5), (2,2))
B = tl.reshape(tl.arange(5,9), (2,2))
weigths = tl.tensor([2,-1], **tl.context(A))
out = cp_to_tensor((weigths, [A,B]))
expected = tl.tensor([[-2,-2], [6, 10]]) # computed by hand
assert_array_equal(out, expected)
(weigths, factors) = random_cp((5, 5, 5), rank=5, normalise_factors=True, full=False)
true_res = tl.dot(tl.dot(factors[0], tl.diag(weigths)),
tl.transpose(tl.tenalg.khatri_rao(factors[1:])))
true_res = tl.fold(true_res, 0, (5, 5, 5))
res = cp_to_tensor((weigths, factors))
assert_array_almost_equal(true_res, res,
err_msg='weights incorrectly incorporated in cp_to_tensor')
# -*- coding: utf-8 -*-
"""
Basic tensor operations
=======================
Example on how to use :mod:`tensorly` to perform basic tensor operations.
"""
import numpy as np
import tensorly as tl
from tensorly.testing import assert_array_equal
###########################################################################
# A tensor is simply a numpy array
tensor = tl.tensor(np.arange(24).reshape((3, 4, 2)))
print('* original tensor:\n{}'.format(tensor))
###########################################################################
# Unfolding a tensor is easy
for mode in range(tensor.ndim):
print('* mode-{} unfolding:\n{}'.format(mode, tl.unfold(tensor, mode)))
###########################################################################
# Re-folding the tensor is as easy:
for mode in range(tensor.ndim):
unfolding = tl.unfold(tensor, mode)
folded = tl.fold(unfolding, mode, tensor.shape)
assert_array_equal(folded, tensor)
