forked from mindspore-Ecosystem/mindspore
move testcases
This commit is contained in:
zhujingxuan
parent
60bfef499f
commit
a18b9e703e
|
|
@ -1,43 +0,0 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
from typing import Generic
|
||||
import mindspore.context as context
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.linalg import cholesky
|
||||
import scipy as scp
|
||||
import numpy as np
|
||||
|
||||
import pytest
|
||||
|
||||
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
|
||||
np.random.seed(0)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('lower', [True])
|
||||
@pytest.mark.parametrize('dtype', [np.float64])
|
||||
def test_cholesky(lower: bool, dtype: Generic):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for cholesky [N,N]
|
||||
Expectation: the result match scipy cholesky
|
||||
"""
|
||||
a = np.array([[4, 12, -6], [12, 37, -43], [-16, -43, 98]], dtype=dtype)
|
||||
tensor_a = Tensor(a)
|
||||
scp_c = scp.linalg.cholesky(a, lower=lower)
|
||||
mscp_c = cholesky(tensor_a, lower=lower)
|
||||
assert np.allclose(scp_c, mscp_c.asnumpy())
|
||||
|
|
@ -1,99 +0,0 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
"""test for solve eigenvalues & eigen vectors"""
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
import mindspore.context as context
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.ops import EigNet
|
||||
|
||||
np.random.seed(0)
|
||||
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
|
||||
|
||||
|
||||
def match(v, v_, error=0):
|
||||
if error > 0:
|
||||
np.testing.assert_almost_equal(v, v_, decimal=error)
|
||||
else:
|
||||
np.testing.assert_equal(v, v_)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('n', [4, 6, 9, 10])
|
||||
@pytest.mark.platform_x86_cpu
|
||||
def test_eig_net(n: int):
|
||||
"""
|
||||
Feature: ALL To ALL
|
||||
Description: test cases for eigen decomposition test cases for Ax= lambda * x /( A- lambda * E)X=0
|
||||
Expectation: the result match to numpy
|
||||
"""
|
||||
# test for real scalar float 32
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
msp_eig = EigNet(True)
|
||||
A = np.array(np.random.rand(n, n), dtype=np.float32)
|
||||
tensor_a = Tensor(np.array(A).astype(np.float32))
|
||||
msp_w, msp_v = msp_eig(tensor_a)
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for real scalar double 64
|
||||
A = np.array(np.random.rand(n, n), dtype=np.float64)
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
msp_eig = EigNet(True)
|
||||
msp_w, msp_v = msp_eig(Tensor(np.array(A).astype(np.float64)))
|
||||
|
||||
# Compare with scipy
|
||||
# sp_w, sp_v = sp.linalg.eig(A.astype(np.float64))
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for complex64
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex64)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
msp_eig = EigNet(True)
|
||||
msp_w, msp_v = msp_eig(Tensor(np.array(A).astype(np.complex64)))
|
||||
# Compare with scipy, scipy passed
|
||||
# sp_w, sp_v = sp.linalg.eig(A.astype(np.complex128))
|
||||
# assert np.allclose(A @ sp_v - sp_v @ np.diag(sp_w), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# print(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()))
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test for complex128
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex128)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
msp_eig = EigNet(True)
|
||||
msp_w, msp_v = msp_eig(Tensor(np.array(A).astype(np.complex128)))
|
||||
# Com`pare with scipy, scipy passed
|
||||
# sp_w, sp_v = sp.linalg.eig(A.astype(np.complex128))
|
||||
# assert np.allclose(A @ sp_v - sp_v @ np.diag(sp_w), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
msp_eig = EigNet(False)
|
||||
msp_w0 = msp_eig(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(msp_w0.asnumpy() - msp_w.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
|
@ -1,133 +0,0 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
"""test for solve eigenvalues & eigen vectors"""
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
import mindspore.context as context
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.ops import EighNet
|
||||
|
||||
np.random.seed(0)
|
||||
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
|
||||
|
||||
|
||||
def match(v, v_, error=0):
|
||||
if error > 0:
|
||||
np.testing.assert_almost_equal(v, v_, decimal=error)
|
||||
else:
|
||||
np.testing.assert_equal(v, v_)
|
||||
|
||||
|
||||
def create_sym_pos_matrix(m, n, dtype):
|
||||
a = (np.random.random((m, n)) + np.eye(m, n)).astype(dtype)
|
||||
return np.dot(a, a.T)
|
||||
|
||||
|
||||
@pytest.mark.parametrize('n', [4, 6, 9, 10])
|
||||
@pytest.mark.platform_x86_cpu
|
||||
def test_eigh_net(n: int):
|
||||
"""
|
||||
Feature: ALL To ALL
|
||||
Description: test cases for eigen decomposition test cases for Ax= lambda * x /( A- lambda * E)X=0
|
||||
Expectation: the result match to numpy
|
||||
"""
|
||||
# test for real scalar float 32
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
|
||||
A = create_sym_pos_matrix(n, n, np.float32)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).T)
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test case for real scalar double 64
|
||||
A = np.random.rand(n, n)
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).T)
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
# test for real scalar float64 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for complex64
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex64)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test for complex128
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex128)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test for real scalar complex128 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
|
@ -1,104 +0,0 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
"""test for SolveTriangular"""
|
||||
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
from scipy.linalg import solve_triangular
|
||||
import mindspore.context as context
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.linalg import solve_triangular as mind_solve
|
||||
|
||||
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
|
||||
np.random.seed(0)
|
||||
|
||||
|
||||
def match(a, b, lower, unit_diagonal, trans):
|
||||
sci_x = solve_triangular(
|
||||
a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
mind_x = mind_solve(Tensor(a), Tensor(
|
||||
b), lower=lower, unit_diagonal=unit_diagonal, trans=trans).asnumpy()
|
||||
|
||||
print(a.flatten())
|
||||
print(b.flatten())
|
||||
print(sci_x.flatten())
|
||||
print(mind_x.flatten())
|
||||
print(f'lower: {lower}, unit_diagonal: {unit_diagonal}, trans: {trans}')
|
||||
np.testing.assert_almost_equal(sci_x, mind_x, decimal=5)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [10, 20])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False])
|
||||
def test_2d(n: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N X 1]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
# add Identity matrix to make matrix A non-singular
|
||||
a = (np.random.random((n, n)) + np.eye(n)).astype(dtype)
|
||||
b = np.random.random((n, 1)).astype(dtype)
|
||||
match(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [10, 20])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False, True])
|
||||
def test_1d(n: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
# add Identity matrix to make matrix A non-singular
|
||||
a = (np.random.random((n, n)) + np.eye(n)).astype(dtype)
|
||||
b = np.random.random(n).astype(dtype)
|
||||
match(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('shape', [(10, 20)])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False, True])
|
||||
def test_matrix(shape: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
if trans == 'T':
|
||||
n, m = shape
|
||||
else:
|
||||
m, n = shape
|
||||
# add Identity matrix to make matrix A non-singular
|
||||
a = (np.random.random((m, m)) + np.eye(m)).astype(dtype)
|
||||
b = np.random.random((m, n)).astype(dtype)
|
||||
match(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
|
|
@ -1,41 +0,0 @@
|
|||
# Copyright 2020 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
from typing import Generic
|
||||
import mindspore.context as context
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.linalg import cholesky
|
||||
import numpy as np
|
||||
import scipy as scp
|
||||
import pytest
|
||||
|
||||
context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('lower', [True])
|
||||
@pytest.mark.parametrize('dtype', [np.float64])
|
||||
def test_scipy_cholesky(lower: bool, dtype: Generic):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for new scipy cholesky [N,N]
|
||||
Expectation: the result match scipy cholesky
|
||||
"""
|
||||
a = np.array([[4, 12, -16], [12, 37, -43], [-16, -43, 98]]).astype(dtype=dtype)
|
||||
tensor_a = Tensor(a)
|
||||
output = cholesky(tensor_a, lower=lower)
|
||||
expect = scp.linalg.cholesky(a, lower=lower)
|
||||
assert np.allclose(expect, output.asnumpy())
|
||||
|
|
@ -1,127 +0,0 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
"""test for solve eigenvalues & eigen vectors"""
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.ops import EighNet
|
||||
|
||||
np.random.seed(0)
|
||||
|
||||
|
||||
def match(v, v_, error=0):
|
||||
if error > 0:
|
||||
np.testing.assert_almost_equal(v, v_, decimal=error)
|
||||
else:
|
||||
np.testing.assert_equal(v, v_)
|
||||
|
||||
|
||||
def create_sym_pos_matrix(m, n, dtype):
|
||||
a = (np.random.random((m, n)) + np.eye(m, n)).astype(dtype)
|
||||
return np.dot(a, a.T)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [4, 6, 8, 20])
|
||||
def test_eigh_net(n: int):
|
||||
"""
|
||||
Feature: ALL To ALL
|
||||
Description: test cases for eigen decomposition test cases for Ax= lambda * x /( A- lambda * E)X=0
|
||||
Expectation: the result match to numpy
|
||||
"""
|
||||
# test for real scalar float 32
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = create_sym_pos_matrix(n, n, np.float32)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
assert np.allclose(A @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(A @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test case for real scalar double 64
|
||||
A = create_sym_pos_matrix(n, n, np.float64)
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
assert np.allclose(A @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(A @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
# test for real scalar float64 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for complex64
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex64)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test for complex128
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex128)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
# test for real scalar complex128 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
|
@ -1,102 +0,0 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
"""test for SolveTriangular"""
|
||||
|
||||
|
||||
import pytest
|
||||
import numpy as np
|
||||
from scipy.linalg import solve_triangular
|
||||
import mindspore.context as context
|
||||
from mindspore import Tensor
|
||||
from mindspore.scipy.linalg import solve_triangular as mind_solve
|
||||
|
||||
context.set_context(mode=context.GRAPH_MODE, device_target="GPU")
|
||||
np.random.seed(0)
|
||||
|
||||
|
||||
def match(a, b, lower, unit_diagonal, trans):
|
||||
sci_x = solve_triangular(
|
||||
a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
mind_x = mind_solve(Tensor(a), Tensor(
|
||||
b), lower=lower, unit_diagonal=unit_diagonal, trans=trans).asnumpy()
|
||||
|
||||
print(sci_x.flatten())
|
||||
print(mind_x.flatten())
|
||||
print(f'lower: {lower}, unit_diagonal: {unit_diagonal}, trans: {trans}')
|
||||
np.testing.assert_almost_equal(sci_x, mind_x, decimal=5)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [10, 20])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False])
|
||||
def test_2d(n: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N X 1]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
# add Identity matrix to make matrix A non-singular
|
||||
a = (np.random.random((n, n)) + np.eye(n)).astype(dtype)
|
||||
b = np.random.random((n, 1)).astype(dtype)
|
||||
match(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [10, 20])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False, True])
|
||||
def test_1d(n: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
# add Identity matrix to make matrix A non-singular
|
||||
a = (np.random.random((n, n)) + np.eye(n)).astype(dtype)
|
||||
b = np.random.random(n).astype(dtype)
|
||||
match(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('shape', [(4, 5), (10, 20)])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False, True])
|
||||
def test_matrix(shape: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
if trans == 'T':
|
||||
n, m = shape
|
||||
else:
|
||||
m, n = shape
|
||||
# add Identity matrix to make matrix A non-singular
|
||||
a = (np.random.random((m, m)) + np.eye(m)).astype(dtype)
|
||||
b = np.random.random((m, n)).astype(dtype)
|
||||
match(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
|
|
@ -0,0 +1,389 @@
|
|||
# Copyright 2021 Huawei Technologies Co., Ltd
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
# ============================================================================
|
||||
"""st for scipy.ops."""
|
||||
from typing import Generic
|
||||
import pytest
|
||||
import numpy as np
|
||||
import scipy as scp
|
||||
from scipy.linalg import solve_triangular
|
||||
|
||||
from mindspore import Tensor, context
|
||||
from mindspore.scipy.ops import EighNet, EigNet, Cholesky, SolveTriangular
|
||||
from tests.st.scipy_st.utils import create_sym_pos_matrix
|
||||
|
||||
np.random.seed(0)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [3, 5, 7])
|
||||
@pytest.mark.parametrize('lower', [True, False])
|
||||
@pytest.mark.parametrize('dtype', [np.float64])
|
||||
def test_cholesky(n: int, lower: bool, dtype: Generic):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for cholesky [N,N]
|
||||
Expectation: the result match scipy cholesky
|
||||
"""
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
a = create_sym_pos_matrix((n, n), dtype)
|
||||
tensor_a = Tensor(a)
|
||||
expect = scp.linalg.cholesky(a, lower=lower)
|
||||
cholesky_net = Cholesky(lower=lower, clean=True)
|
||||
output = cholesky_net(tensor_a)
|
||||
assert np.allclose(expect, output.asnumpy())
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [4, 6, 9, 10])
|
||||
def test_eig_net(n: int):
|
||||
"""
|
||||
Feature: ALL To ALL
|
||||
Description: test cases for eigen decomposition test cases for Ax= lambda * x /( A- lambda * E)X=0
|
||||
Expectation: the result match to numpy
|
||||
"""
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
# test for real scalar float 32
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
msp_eig = EigNet(True)
|
||||
A = np.array(np.random.rand(n, n), dtype=np.float32)
|
||||
tensor_a = Tensor(np.array(A).astype(np.float32))
|
||||
msp_w, msp_v = msp_eig(tensor_a)
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for real scalar double 64
|
||||
A = np.array(np.random.rand(n, n), dtype=np.float64)
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
msp_eig = EigNet(True)
|
||||
msp_w, msp_v = msp_eig(Tensor(np.array(A).astype(np.float64)))
|
||||
|
||||
# Compare with scipy
|
||||
# sp_w, sp_v = sp.linalg.eig(A.astype(np.float64))
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for complex64
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex64)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
msp_eig = EigNet(True)
|
||||
msp_w, msp_v = msp_eig(Tensor(np.array(A).astype(np.complex64)))
|
||||
# Compare with scipy, scipy passed
|
||||
# sp_w, sp_v = sp.linalg.eig(A.astype(np.complex128))
|
||||
# assert np.allclose(A @ sp_v - sp_v @ np.diag(sp_w), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# print(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()))
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test for complex128
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex128)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
msp_eig = EigNet(True)
|
||||
msp_w, msp_v = msp_eig(Tensor(np.array(A).astype(np.complex128)))
|
||||
# Com`pare with scipy, scipy passed
|
||||
# sp_w, sp_v = sp.linalg.eig(A.astype(np.complex128))
|
||||
# assert np.allclose(A @ sp_v - sp_v @ np.diag(sp_w), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(A @ msp_v.asnumpy() - msp_v.asnumpy() @ np.diag(msp_w.asnumpy()), np.zeros((n, n)), rtol, atol)
|
||||
msp_eig = EigNet(False)
|
||||
msp_w0 = msp_eig(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(msp_w0.asnumpy() - msp_w.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [4, 6, 9, 10])
|
||||
def test_eigh_net_cpu(n: int):
|
||||
"""
|
||||
Feature: ALL To ALL
|
||||
Description: test cases for eigen decomposition test cases for Ax= lambda * x /( A- lambda * E)X=0
|
||||
Expectation: the result match to numpy
|
||||
"""
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
# test for real scalar float 32
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
|
||||
A = create_sym_pos_matrix((n, n), np.float32)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).T)
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test case for real scalar double 64
|
||||
A = np.random.rand(n, n)
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).T)
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
# test for real scalar float64 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for complex64
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex64)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test for complex128
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex128)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test for real scalar complex128 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [4, 6, 8, 20])
|
||||
def test_eigh_net_gpu(n: int):
|
||||
"""
|
||||
Feature: ALL To ALL
|
||||
Description: test cases for eigen decomposition test cases for Ax= lambda * x /( A- lambda * E)X=0
|
||||
Expectation: the result match to numpy
|
||||
"""
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
# test for real scalar float 32
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = create_sym_pos_matrix((n, n), np.float32)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float32)))
|
||||
assert np.allclose(A @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(A @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
|
||||
# test case for real scalar double 64
|
||||
A = create_sym_pos_matrix((n, n), np.float64)
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
assert np.allclose(A @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
assert np.allclose(A @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()), np.zeros((n, n)), rtol,
|
||||
atol)
|
||||
# test for real scalar float64 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.float64)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test case for complex64
|
||||
rtol = 1e-3
|
||||
atol = 1e-4
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex64)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex64)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
|
||||
# test for complex128
|
||||
rtol = 1e-5
|
||||
atol = 1e-8
|
||||
A = np.array(np.random.rand(n, n), dtype=np.complex128)
|
||||
for i in range(0, n):
|
||||
for j in range(0, n):
|
||||
if i == j:
|
||||
A[i][j] = complex(np.random.rand(1, 1), 0)
|
||||
else:
|
||||
A[i][j] = complex(np.random.rand(1, 1), np.random.rand(1, 1))
|
||||
sym_Al = (np.tril((np.tril(A) - np.tril(A).T)) + np.tril(A).conj().T)
|
||||
sym_Au = (np.triu((np.triu(A) - np.triu(A).T)) + np.triu(A).conj().T)
|
||||
msp_eigh = EighNet(True, True)
|
||||
msp_wl, msp_vl = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(True, False)
|
||||
msp_wu, msp_vu = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(sym_Al @ msp_vl.asnumpy() - msp_vl.asnumpy() @ np.diag(msp_wl.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(sym_Au @ msp_vu.asnumpy() - msp_vu.asnumpy() @ np.diag(msp_wu.asnumpy()),
|
||||
np.zeros((n, n)), rtol, atol)
|
||||
# test for real scalar complex128 no vector
|
||||
msp_eigh = EighNet(False, True)
|
||||
msp_wl0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
msp_eigh = EighNet(False, False)
|
||||
msp_wu0 = msp_eigh(Tensor(np.array(A).astype(np.complex128)))
|
||||
assert np.allclose(msp_wl.asnumpy() - msp_wl0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
assert np.allclose(msp_wu.asnumpy() - msp_wu0.asnumpy(), np.zeros((n, n)), rtol, atol)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [10, 20])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False])
|
||||
def test_solve_triangular_2d(n: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N X 1]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
a = (np.random.random((n, n)) + np.eye(n)).astype(dtype)
|
||||
b = np.random.random((n, 1)).astype(dtype)
|
||||
expect = solve_triangular(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
solve = SolveTriangular(lower, unit_diagonal, trans)
|
||||
output = solve(Tensor(a), Tensor(b)).asnumpy()
|
||||
np.testing.assert_almost_equal(expect, output, decimal=5)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('n', [10, 20])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False, True])
|
||||
def test_solve_triangular_1d(n: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
a = (np.random.random((n, n)) + np.eye(n)).astype(dtype)
|
||||
b = np.random.random(n).astype(dtype)
|
||||
expect = solve_triangular(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
solve = SolveTriangular(lower, unit_diagonal, trans)
|
||||
output = solve(Tensor(a), Tensor(b)).asnumpy()
|
||||
np.testing.assert_almost_equal(expect, output, decimal=5)
|
||||
|
||||
|
||||
@pytest.mark.level0
|
||||
@pytest.mark.platform_x86_cpu
|
||||
@pytest.mark.platform_x86_gpu_training
|
||||
@pytest.mark.env_onecard
|
||||
@pytest.mark.parametrize('shape', [(4, 5), (10, 20)])
|
||||
@pytest.mark.parametrize('trans', ["N", "T"])
|
||||
@pytest.mark.parametrize('dtype', [np.float32, np.float64])
|
||||
@pytest.mark.parametrize('lower', [False, True])
|
||||
@pytest.mark.parametrize('unit_diagonal', [False, True])
|
||||
def test_solve_triangular_matrix(shape: int, dtype, lower: bool, unit_diagonal: bool, trans: str):
|
||||
"""
|
||||
Feature: ALL TO ALL
|
||||
Description: test cases for [N x N] X [N]
|
||||
Expectation: the result match scipy
|
||||
"""
|
||||
if trans == 'T':
|
||||
n, m = shape
|
||||
else:
|
||||
m, n = shape
|
||||
context.set_context(mode=context.GRAPH_MODE)
|
||||
a = (np.random.random((m, m)) + np.eye(m)).astype(dtype)
|
||||
b = np.random.random((m, n)).astype(dtype)
|
||||
expect = solve_triangular(a, b, lower=lower, unit_diagonal=unit_diagonal, trans=trans)
|
||||
solve = SolveTriangular(lower, unit_diagonal, trans)
|
||||
output = solve(Tensor(a), Tensor(b)).asnumpy()
|
||||
np.testing.assert_almost_equal(expect, output, decimal=5)
|
||||
Loading…
Reference in New Issue