1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107 | import numpy as np
from numpy.linalg import qr
from ..kruskal_tensor import kruskal_to_tensor
from ..tucker_tensor import tucker_to_tensor
from .. import backend as T
def check_random_state(seed):
"""Returns a valid RandomState
Parameters
----------
seed : None or instance of int or np.random.RandomState(), default is None
Returns
-------
Valid instance np.random.RandomState
Notes
-----
Inspired by the scikit-learn eponymous function
"""
if seed is None or isinstance(seed, int):
return np.random.RandomState(seed)
elif isinstance(seed, np.random.RandomState):
return seed
raise ValueError('Seed should be None, int or np.random.RandomState')
def cp_tensor(shape, rank, full=False, orthogonal=False, random_state=None):
"""Generates a random CP tensor
Parameters
----------
shape : tuple
shape of the tensor to generate
rank : int
rank of the CP decomposition
full : bool, optional, default is False
if True, a full tensor is returned
otherwise, the decomposed tensor is returned
orthogonal : bool, optional, default is False
if True, creates a tensor with orthogonal components
random_state : `np.random.RandomState`
Returns
-------
cp_tensor : ND-array or 2D-array list
ND-array : full tensor if `full` is True
2D-array list : list of factors otherwise
"""
if (rank > min(shape)) and orthogonal:
raise ValueError('Can only construct orthogonal tensors when rank <= '
'min(shape)')
rns = check_random_state(random_state)
factors = [T.tensor(rns.random_sample((s, rank))) for s in shape]
if orthogonal:
factors = [T.qr(factor)[0] for factor in factors]
if full:
return kruskal_to_tensor(factors)
else:
return factors
def tucker_tensor(shape, rank, full=False, random_state=None):
"""Generates a random Tucker tensor
Parameters
----------
shape : tuple
shape of the tensor to generate
rank : int or int list
rank of the Tucker decomposition
if int, the same rank is used for each mode
otherwise, dimension of each mode
full : bool, optional, default is False
if True, a full tensor is returned
otherwise, the decomposed tensor is returned
random_state : `np.random.RandomState`
Returns
-------
tucker_tensor : ND-array or (ND-array, 2D-array list)
ND-array : full tensor if `full` is True
(ND-array, 2D-array list) : core tensor and list of factors otherwise
"""
rns = check_random_state(random_state)
if isinstance(rank, int):
rank = [rank for _ in shape]
for i, (s, r) in enumerate(zip(shape, rank)):
if r > s:
raise ValueError('The rank should be smaller than the tensor size, yet rank[{0}]={1} > shape[{0}]={2}.'.format(i, r, s))
factors = []
for (s, r) in zip(shape, rank):
Q, _= qr(rns.random_sample((s, s)))
factors.append(T.tensor(Q[:, :r]))
core = T.tensor(rns.random_sample(rank))
if full:
return tucker_to_tensor(core, factors)
else:
return core, factors
|