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)