Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def test_matrix_product_state_cross_1():
""" Test for matrix_product_state """
rng = check_random_state(1234)
## Test 1
# Create tensor with random elements
d = 3
n = 4
tensor = (np.arange(n**d).reshape((n,)*d))
tensor = tl.tensor(tensor)
tensor_shape = tensor.shape
# Find MPS decomposition of the tensor
rank = [1, 3,3, 1]
factors = matrix_product_state_cross(tensor, rank, tol=1e-5, n_iter_max=10)
assert(len(factors) == d), "Number of factors should be 4, 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(d):
(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 "
def test_matrix_product_state_cross_2():
""" Test for matrix_product_state """
rng = check_random_state(1234)
## Test 2
# Create tensor with random elements
tensor = tl.tensor(rng.random_sample([3, 4, 5, 6, 2, 10]))
tensor_shape = tensor.shape
# Find MPS decomposition of the tensor
rank = [1, 3, 3, 4, 2, 2, 1]
factors = matrix_product_state_cross(tensor, rank)
for k in range(6):
(r_prev, n_k, r_k) = factors[k].shape
first_error_message = "MPS 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 = "MPS 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
svd_fun = tl.SVD_FUNS[svd]
except KeyError:
message = 'Got svd={}. However, for the current backend ({}), the possible choices are {}'.format(
svd, tl.get_backend(), tl.SVD_FUNS)
raise ValueError(message)
# SVD init
if init == 'svd':
factors = []
for index, mode in enumerate(modes):
eigenvecs, _, _ = svd_fun(unfold(tensor, mode), n_eigenvecs=rank[index])
factors.append(eigenvecs)
else:
rng = check_random_state(random_state)
core = tl.tensor(rng.random_sample(rank), **tl.context(tensor))
factors = [tl.tensor(rng.random_sample((tl.shape(tensor)[mode], rank[index])), **tl.context(tensor)) for (index, mode) in enumerate(modes)]
rec_errors = []
norm_tensor = tl.norm(tensor, 2)
for iteration in range(n_iter_max):
for index, mode in enumerate(modes):
core_approximation = multi_mode_dot(tensor, factors, modes=modes, skip=index, transpose=True)
eigenvecs, _, _ = svd_fun(unfold(core_approximation, mode), n_eigenvecs=rank[index])
factors[index] = eigenvecs
core = multi_mode_dot(tensor, factors, modes=modes, transpose=True)
# The factors are orthonormal and therefore do not affect the reconstructed tensor's norm
rec_error = sqrt(abs(norm_tensor**2 - tl.norm(core, 2)**2)) / norm_tensor
rec_errors.append(rec_error)
# -*- 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)
# Generate random samples
rng = check_random_state(1)
X = tl.tensor(rng.normal(size=(1000, image_height, image_width), loc=0, scale=1))
# Parameters of the plot, deduced from the data
n_rows = len(patterns)
n_columns = len(ranks) + 1
# Plot the three images
fig = plt.figure()
for i, pattern in enumerate(patterns):
# Generate the original image
weight_img = gen_image(region=pattern, image_height=image_height, image_width=image_width)
weight_img = tl.tensor(weight_img)
# Generate the labels
y = tl.dot(partial_tensor_to_vec(X, skip_begin=1), tensor_to_vec(weight_img))
# Plot the original weights
ax = fig.add_subplot(n_rows, n_columns, i*n_columns + 1)
ax.imshow(tl.to_numpy(weight_img), cmap=plt.cm.OrRd, interpolation='nearest')
ax.set_axis_off()
if i == 0:
ax.set_title('Original\nweights')
for j, rank in enumerate(ranks):
# Create a tensor Regressor estimator
estimator = KruskalRegressor(weight_rank=rank, tol=10e-7, n_iter_max=100, reg_W=1, verbose=0)
idx[k - 1] = slice(None, None, None)
idx = tuple(idx)
core = input_tensor[idx]
# shape the core as a 3-tensor_order cube
core = tl.reshape(core, (rank[k - 1], rank[k], tensor_shape[k - 1]))
core = tl.transpose(core, (0, 2, 1))
# merge n_{k-1} and r_k, get a matrix
core = tl.reshape(core, (rank[k - 1], tensor_shape[k - 1] * rank[k]))
core = tl.transpose(core)
# Compute QR decomposition
(Q, R) = tl.qr(core)
# Maxvol
(J, Q_inv) = maxvol(Q)
Q_inv = tl.tensor(Q_inv)
Q_skeleton = tl.dot(Q, Q_inv)
# Retrive indices in folded tensor
new_idx = [np.unravel_index(idx, [tensor_shape[k - 1], rank[k]]) for idx in J] # First retrive idx in folded core
next_col_idx = [(jc[0],) + col_idx[k - 1][jc[1]] for jc in new_idx] # Then reconstruct the idx in the tensor
return (next_col_idx, fibers_list, Q_skeleton)