def test_eye():
test_case = Cases()
for i in range(len(test_case.onp_dtypes)):
for m in range(1, 5):
actual = onp.eye(m, dtype=test_case.onp_dtypes[i])
expected = mnp.eye(m, dtype=test_case.mnp_dtypes[i]).asnumpy()
match_array(actual, expected)
for n in range(1, 5):
for k in range(0, 5):
actual = onp.eye(m, n, k, dtype=test_case.onp_dtypes[i])
expected = mnp.eye(
m, n, k, dtype=test_case.mnp_dtypes[i]).asnumpy()
match_array(actual, expected)
def compute_A_phi(model, norm="none", square=False):
"""
compute matrix A consisting of products of NN weights
Parameters
----------
model: instantiating model objects
'NonLinGaussANM' or 'NonLinGauss'
norm: str, default 'none'
use norm of product of paths, 'none' or 'paths'
'paths': use norm, 'none': with no norm
square: bool, default False
use squared product of paths
"""
weights = model.get_parameters(mode='w')[0]
prod = msnp.eye(model.input_dim, dtype=mstype.float32)
if norm == "paths":
prod_norm = msnp.eye(model.input_dim)
for i, w in enumerate(weights):
if square:
w = w**2
else:
w = ops.absolute(w)
if i == 0:
tmp_adj = ops.expand_dims(model.adjacency.transpose(), 1)
ein_one = ops.mul(w, tmp_adj)
prod = ops.matmul(ein_one, prod)
if norm == "paths":
tmp_adj = 1. - msnp.eye(model.input_dim, dtype=mstype.float32)
tmp_adj = ops.expand_dims(tmp_adj.transpose(), 1)
ein_two = ops.mul(ops.ones_like(w), tmp_adj)
prod_norm = ops.matmul(ein_two, prod_norm)
else:
prod = ops.matmul(w, prod)
if norm == "paths":
prod_norm = ops.matmul(ops.ones_like(w), prod_norm)
# sum over density parameter axis
prod = ops.reduce_sum(prod, 1)
if norm == "paths":
prod_norm = ops.reduce_sum(prod_norm, 1)
# avoid / 0 on diagonal
denominator = prod_norm + msnp.eye(model.input_dim,
dtype=mstype.float32)
return (prod / denominator).transpose()
elif norm == "none":
return prod.transpose()
else:
raise NotImplementedError
def __init__(self,
input_dim,
hidden_num,
hidden_dim,
output_dim,
mu,
lamb,
nonlinear="leaky-relu",
norm_prod='paths',
square_prod=False):
super(BaseModel, self).__init__()
self.input_dim = input_dim
self.hidden_num = hidden_num
self.hidden_dim = hidden_dim
self.output_dim = output_dim
self.mu = mu
self.lamb = lamb
self.nonlinear = nonlinear
self.norm_prod = norm_prod
self.square_prod = square_prod
self.normal = msd.Normal(dtype=mstype.float32)
self.extra_params = []
# initialize current adjacency matrix
self.adjacency = msnp.ones(
(self.input_dim, self.input_dim), dtype=mstype.float32) - msnp.eye(
self.input_dim, dtype=mstype.float32)
# Generate layer_list
layer_list = [self.hidden_dim] * self.hidden_num
layer_list.insert(0, self.input_dim)
layer_list.append(self.output_dim)
# Instantiate the parameters of each layer in the model of each variable
tmp_weights = list()
tmp_biases = list()
for i, item in enumerate(layer_list[:-1]):
in_dim = item
out_dim = layer_list[i + 1]
tmp_weights.append(
Parameter(msnp.zeros((self.input_dim, out_dim, in_dim),
dtype=mstype.float32),
requires_grad=True,
name='w' + str(i)))
tmp_biases.append(
Parameter(msnp.zeros((self.input_dim, out_dim),
dtype=mstype.float32),
requires_grad=True,
name='b' + str(i)))
self.weights = ParameterTuple(tmp_weights)
self.biases = ParameterTuple(tmp_biases)
# reset initialization parameters
self.reset_params()
def MeanShift(x,
rgb_range,
rgb_mean=(0.4488, 0.4371, 0.4040),
rgb_std=(1.0, 1.0, 1.0),
sign=-1):
# super(MeanShift, self).__init__(3, 3, kernel_size=1)
std = Tensor(rgb_std)
conv2d = ops.Conv2D(out_channel=3, kernel_size=1)
biasadd = ops.BiasAdd()
weight = numpy.eye(3, 3).view((3, 3, 1, 1)) / std.view(3, 1, 1, 1)
bias = sign * rgb_range * Tensor(rgb_mean) / std
weight = weight.astype(numpy.float32)
bias = bias.astype(numpy.float32)
x = conv2d(x, weight)
x = biasadd(x, bias)
return x
def get_matrix_exp(matrix):
"""
compute matrix exponent
Parameters
----------
matrix: mindspore.Tensor
Returns
-------
expm: matrix exponent value of A
"""
expm_val = msnp.zeros(matrix.shape, dtype=mstype.float32)
eye_mat = msnp.eye(matrix.shape[0], dtype=mstype.float32)
k = 1.0
while msnp.norm(eye_mat, 1) > 0:
expm_val = expm_val + eye_mat
eye_mat = msnp.matmul(matrix, eye_mat) / k
k += 1.0
return expm_val
def eye(n, m=None, dtype=mstype.float32):
return mnp.eye(n, m, dtype=dtype)