def test_tensor_product(): """Test tensor_dot""" rng = random.check_random_state(1234) X = tl.tensor(rng.random_sample((4, 5, 6))) Y = tl.tensor(rng.random_sample((3, 4, 7))) tdot = tl.tensor_to_vec(tensor_dot(X, Y)) true_dot = tl.tensor_to_vec( tenalg.outer([tl.tensor_to_vec(X), tl.tensor_to_vec(Y)])) testing.assert_array_almost_equal(tdot, true_dot)
def test_batched_tensor_product(): """Test batched-tensor_dot Notes ----- At the time of writing, MXNet doesn't support transpose for tensors of order higher than 6 """ rng = random.check_random_state(1234) batch_size = 3 X = tl.tensor(rng.random_sample((batch_size, 4, 5, 6))) Y = tl.tensor(rng.random_sample((batch_size, 3, 7))) tdot = tl.unfold(batched_tensor_dot(X, Y), 0) for i in range(batch_size): true_dot = tl.tensor_to_vec( tenalg.outer([tl.tensor_to_vec(X[i]), tl.tensor_to_vec(Y[i])])) testing.assert_array_almost_equal(tdot[i], true_dot)
def power_iteration(tensor, n_repeat=10, n_iteration=10, verbose=False): """A single Robust Tensor Power Iteration Parameters ---------- tensor : tl.tensor input tensor to decompose n_repeat : int, default is 10 number of initializations to be tried n_iteration : int, default is 10 number of power iterations verbose : bool level of verbosity Returns ------- (eigenval, best_factor, deflated) eigenval : float the obtained eigenvalue best_factors : tl.tensor list the best estimated eigenvector, for each mode of the input tensor deflated : tl.tensor of same shape as `tensor` the deflated tensor (i.e. without the estimated component) """ order = tl.ndim(tensor) # A list of candidates for each mode best_score = 0 scores = [] for _ in range(n_repeat): factors = [ tl.tensor(np.random.random_sample(s), **tl.context(tensor)) for s in tl.shape(tensor) ] for _ in range(n_iteration): for mode in range(order): factor = tl.tenalg.multi_mode_dot(tensor, factors, skip=mode) factor = factor / tl.norm(factor, 2) factors[mode] = factor score = tl.tenalg.multi_mode_dot(tensor, factors) scores.append(score) #round(score, 2)) if score > best_score: best_score = score best_factors = factors if verbose: print(f'Best score of {n_repeat}: {best_score}') # Refine the init for _ in range(n_iteration): for mode in range(order): factor = tl.tenalg.multi_mode_dot(tensor, best_factors, skip=mode) factor = factor / tl.norm(factor, 2) best_factors[mode] = factor eigenval = tl.tenalg.multi_mode_dot(tensor, best_factors) deflated = tensor - outer(best_factors) * eigenval if verbose: explained = tl.norm(deflated) / tl.norm(tensor) print(f'Eingenvalue: {eigenval}, explained: {explained}') return eigenval, best_factors, deflated
def symmetric_power_iteration(tensor, n_repeat=10, n_iteration=10, verbose=False): """A single Robust Symmetric Tensor Power Iteration Parameters ---------- tensor : tl.tensor input tensor to decompose, must be symmetric of shape (size, )*order n_repeat : int, default is 10 number of initializations to be tried n_iterations : int, default is 10 number of power iterations verbose : bool level of verbosity Returns ------- (eigenval, best_factor, deflated) eigenval : float the obtained eigenvalue best_factor: tl.tensor the best estimated eigenvector deflated : tl.tensor of same shape as `tensor` the deflated tensor (i.e. without the estimated component) """ order = tl.ndim(tensor) size = tl.shape(tensor)[0] if not tl.shape(tensor) == (size, ) * order: raise ValueError( 'The input tensor does not have the same size along each mode.') # A list of candidates for each mode best_score = 0 scores = [] modes = list(range(1, order)) for _ in range(n_repeat): factor = tl.tensor(np.random.random_sample(size)) for _ in range(n_iteration): for _ in range(order): factor = tl.tenalg.multi_mode_dot(tensor, [factor] * (order - 1), modes=modes) factor = factor / tl.norm(factor, 2) score = tl.tenalg.multi_mode_dot(tensor, [factor] * order) scores.append(score) #round(score, 2)) if score > best_score: best_score = score best_factor = factor if verbose: print(f'Best score of {n_repeat}: {best_score}') # Refine the init for _ in range(n_iteration): for _ in range(order): best_factor = tl.tenalg.multi_mode_dot(tensor, [best_factor] * (order - 1), modes=modes) best_factor = best_factor / tl.norm(best_factor, 2) eigenval = tl.tenalg.multi_mode_dot(tensor, [best_factor] * order) deflated = tensor - outer([best_factor] * 3) * eigenval if verbose: explained = tl.norm(deflated) / tl.norm(tensor) print(f'Eingenvalue: {eigenval}, explained: {explained}') return eigenval, best_factor, deflated