forked from huawei/mindspore2022
774 lines
26 KiB
Python
774 lines
26 KiB
Python
# 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 graph fallback """
|
|
import pytest
|
|
import numpy as np
|
|
from mindspore import ms_function, context, Tensor
|
|
|
|
context.set_context(mode=context.GRAPH_MODE)
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_linspace():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy with linspace in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_linspace():
|
|
a = Tensor(np.linspace(1, 10, 10))
|
|
b = Tensor(np.linspace(1, 1, 10))
|
|
c = Tensor(np.linspace(10, 20, 5, endpoint=False))
|
|
d = Tensor(np.linspace(10, 20, 5, endpoint=True))
|
|
e = Tensor(np.linspace(1, 10, 10).reshape([10, 1]))
|
|
return a, b, c, d, e
|
|
a, b, c, d, e = np_linspace()
|
|
print("a:", a)
|
|
print("b:", b)
|
|
print("c:", c)
|
|
print("d:", d)
|
|
print("e:", e)
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_arange_slice_1():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy with arange slice in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_arange_slice_1():
|
|
x = np.arange(10)
|
|
index = slice(2, 7, 2)
|
|
a = Tensor(x[index])
|
|
b = Tensor(x[2:7:2])
|
|
c = Tensor(x[5])
|
|
d = Tensor(x[2:])
|
|
e = Tensor(x[2:5])
|
|
return a, b, c, d, e
|
|
a, b, c, d, e = np_arange_slice_1()
|
|
assert np.all(a.asnumpy() == np.array([2, 4, 6]))
|
|
assert np.all(b.asnumpy() == np.array([2, 4, 6]))
|
|
assert np.all(c.asnumpy() == np.array([5]))
|
|
assert np.all(d.asnumpy() == np.array([2, 3, 4, 5, 6, 7, 8, 9]))
|
|
assert np.all(e.asnumpy() == np.array([2, 3, 4]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_arange_slice_2():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy with arange slice in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_arange_slice_2():
|
|
x = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
|
|
a = Tensor(x[1:])
|
|
b = Tensor(x[..., 1])
|
|
c = Tensor(x[1, ...])
|
|
d = Tensor(x[..., 1:])
|
|
return a, b, c, d
|
|
a, b, c, d = np_arange_slice_2()
|
|
assert np.all(a.asnumpy() == np.array([[3, 4, 5], [4, 5, 6]]))
|
|
assert np.all(b.asnumpy() == np.array([2, 4, 5]))
|
|
assert np.all(c.asnumpy() == np.array([3, 4, 5]))
|
|
assert np.all(d.asnumpy() == np.array([[2, 3], [4, 5], [5, 6]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_array_advanced_index_1():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy with array advanced index in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_array_advanced_index_1():
|
|
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
|
|
a = Tensor(x[[0, 1, 2], [0, 1, 0]])
|
|
rows = np.array([[0, 0], [3, 3]])
|
|
cols = np.array([[0, 2], [0, 2]])
|
|
b = Tensor(x[rows, cols])
|
|
c = Tensor(x[1:3, 1:3])
|
|
d = Tensor(x[1:3, [1, 2]])
|
|
e = Tensor(x[..., 1:])
|
|
return a, b, c, d, e
|
|
a, b, c, d, e = np_array_advanced_index_1()
|
|
assert np.all(a.asnumpy() == np.array([0, 4, 6]))
|
|
assert np.all(b.asnumpy() == np.array([[0, 2], [9, 11]]))
|
|
assert np.all(c.asnumpy() == np.array([[4, 5], [7, 8]]))
|
|
assert np.all(d.asnumpy() == np.array([[4, 5], [7, 8]]))
|
|
assert np.all(e.asnumpy() == np.array([[1, 2], [4, 5], [7, 8], [10, 11]]))
|
|
|
|
|
|
# Not support <class 'complex'> yet.
|
|
@pytest.mark.skip(reason='Not support graph fallback feature yet')
|
|
def test_np_array_advanced_index_2():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy with array advanced index in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_array_advanced_index_2():
|
|
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
|
|
y = np.array([np.nan, 1, 2, np.nan, 3, 4, 5])
|
|
z = np.array([1, 2 + 6j, 5, 3.5 + 5j])
|
|
a = Tensor(x[x > 5])
|
|
b = Tensor(y[~np.isnan(y)])
|
|
c = Tensor(z[np.iscomplex(z)])
|
|
return a, b, c
|
|
a, b, c = np_array_advanced_index_2()
|
|
assert np.all(a.asnumpy() == np.array([6, 7, 8, 9, 10, 11]))
|
|
assert np.all(b.asnumpy() == np.array([1., 2., 3., 4., 5.]))
|
|
assert np.all(c.asnumpy() == np.array([2. + 6.j, 3.5 + 5.j]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_array_advanced_index_3():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy with array advanced index in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_array_advanced_index_3():
|
|
x = np.arange(32).reshape((8, 4))
|
|
a = Tensor(x[[4, 2, 1, 7]])
|
|
y = np.arange(32).reshape((8, 4))
|
|
b = Tensor(y[[-4, -2, -1, -7]])
|
|
z = np.arange(32).reshape((8, 4))
|
|
c = Tensor(z[np.ix_([1, 5, 7, 2], [0, 3, 1, 2])])
|
|
return a, b, c
|
|
a, b, c = np_array_advanced_index_3()
|
|
print("a:", a)
|
|
print("b:", b)
|
|
print("c:", c)
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_reshape():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.reshape() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_reshape():
|
|
x = np.arange(8)
|
|
y = x.reshape(2, 4)
|
|
return Tensor(y)
|
|
assert np.all(np_reshape().asnumpy() == np.array([[0, 1, 2, 3], [4, 5, 6, 7]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_ndarray_flatten():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.flatten() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_ndarray_flatten():
|
|
x = np.arange(8).reshape(2, 4)
|
|
y = x.flatten()
|
|
return Tensor(y)
|
|
assert np.all(np_ndarray_flatten().asnumpy() == np.array([0, 1, 2, 3, 4, 5, 6, 7]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_ravel():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.ravel() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_ravel():
|
|
x = np.arange(8).reshape(2, 4)
|
|
y = x.ravel(order='F')
|
|
return Tensor(y)
|
|
assert np.all(np_ravel().asnumpy() == np.array([0, 4, 1, 5, 2, 6, 3, 7]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_transpose():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.transpose() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_transpose():
|
|
x = np.arange(4).reshape(4, 1)
|
|
y = np.transpose(x)
|
|
return Tensor(y)
|
|
assert np.all(np_transpose().asnumpy() == np.array([0, 1, 2, 3]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_rollaxis():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.rollaxis() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_rollaxis():
|
|
x = np.arange(8).reshape(2, 2, 2)
|
|
tensor_x = Tensor(x)
|
|
y = np.rollaxis(x, 2, 0)
|
|
tensor_y = Tensor(y)
|
|
return tensor_x[1, 1, 0], tensor_y[1, 1, 0]
|
|
x, y = np_rollaxis()
|
|
assert x == 6 and y == 5
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_swapaxes():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.swapaxes() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_swapaxes():
|
|
x = np.arange(8).reshape(2, 2, 2)
|
|
tensor_x = Tensor(x)
|
|
y = np.swapaxes(x, 2, 0)
|
|
tensor_y = Tensor(y)
|
|
return tensor_x[1, 1, 0], tensor_y[1, 1, 0]
|
|
x, y = np_swapaxes()
|
|
assert x == 6 and y == 3
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_broadcast():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.broadcast() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_broadcast():
|
|
x = np.array([[1], [2], [3]])
|
|
y = np.array([4, 5, 6])
|
|
z = np.broadcast(x, y)
|
|
return Tensor(z.shape)
|
|
assert np.all(np_broadcast().asnumpy() == np.array([3, 3]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_broadcast_to():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.broadcast_to() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_broadcast_to():
|
|
x = np.arange(4).reshape(1, 4)
|
|
y = np.broadcast_to(x, (2, 4))
|
|
return Tensor(y)
|
|
assert np.all(np_broadcast_to().asnumpy() == np.array([[0, 1, 2, 3], [0, 1, 2, 3]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_expand_dims():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.expand_dims() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_expand_dims():
|
|
x = np.array(([1, 2], [3, 4]))
|
|
y = np.expand_dims(x, axis=0)
|
|
return Tensor(y)
|
|
assert np.all(np_expand_dims().asnumpy() == np.array([[[1, 2], [3, 4]]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_squeeze():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy.squeeze() method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_squeeze():
|
|
x = np.arange(4).reshape(1, 2, 2)
|
|
y = np.squeeze(x)
|
|
return Tensor(y)
|
|
assert np.all(np_squeeze().asnumpy() == np.array([[0, 1], [2, 3]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_concat():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_concat():
|
|
x = np.array([[1, 2], [3, 4]])
|
|
y = np.array([[5, 6], [7, 8]])
|
|
concatenate = np.concatenate((x, y))
|
|
stack = np.stack((x, y), 0)
|
|
hstack = np.hstack((x, y))
|
|
vstack = np.vstack((x, y))
|
|
return Tensor(concatenate), Tensor(stack), Tensor(hstack), Tensor(vstack)
|
|
|
|
out_concatenate, out_stack, out_hstack, out_vstack = np_concat()
|
|
assert np.all(out_concatenate.asnumpy() == np.array([[1, 2], [3, 4], [5, 6], [7, 8]]))
|
|
assert np.all(out_stack.asnumpy() == np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]))
|
|
assert np.all(out_hstack.asnumpy() == np.array([[1, 2, 5, 6], [3, 4, 7, 8]]))
|
|
assert np.all(out_vstack.asnumpy() == np.array([[1, 2], [3, 4], [5, 6], [7, 8]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_split():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy split method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_split():
|
|
x = np.arange(4).reshape(2, 2)
|
|
split = np.split(x, 2)
|
|
hsplit = np.hsplit(x, 2)
|
|
vsplit = np.vsplit(x, 2)
|
|
return Tensor(split), Tensor(hsplit), Tensor(vsplit)
|
|
|
|
out_split, out_hsplit, out_vsplit = np_split()
|
|
assert np.all(out_split.asnumpy() == np.array([[[0, 1]], [[2, 3]]]))
|
|
assert np.all(out_hsplit.asnumpy() == np.array([[[0], [2]], [[1], [3]]]))
|
|
assert np.all(out_vsplit.asnumpy() == np.array([[[0, 1]], [[2, 3]]]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_element():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_element():
|
|
resize = np.resize(np.array([[1, 2, 3], [4, 5, 6]]), (3, 2))
|
|
append = np.append(np.array([[1, 2, 3], [4, 5, 6]]), [[7, 8, 9]], axis=0)
|
|
insert = np.insert(np.array([[1, 2], [3, 4], [5, 6]]), 3, [7, 8], axis=0)
|
|
delete = np.delete(np.arange(6).reshape(2, 3), 0, axis=0)
|
|
unique = np.unique(np.array([5, 2, 6, 2, 7, 5, 6, 8, 2, 9]))
|
|
return Tensor(resize), Tensor(append), Tensor(insert), Tensor(delete), Tensor(unique)
|
|
|
|
out_resize, out_append, out_insert, out_delete, out_unique = np_element()
|
|
assert np.all(out_resize.asnumpy() == np.array([[1, 2], [3, 4], [5, 6]]))
|
|
assert np.all(out_append.asnumpy() == np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))
|
|
assert np.all(out_insert.asnumpy() == np.array([[1, 2], [3, 4], [5, 6], [7, 8]]))
|
|
assert np.all(out_delete.asnumpy() == np.array([3, 4, 5]))
|
|
assert np.all(out_unique.asnumpy() == np.array([2, 5, 6, 7, 8, 9]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_bitwise():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy bitwise method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_bitwise():
|
|
bitwise_and = np.bitwise_and(13, 17)
|
|
bitwise_or = np.bitwise_or(13, 17)
|
|
invert = np.invert(np.array([13], dtype=np.uint8))
|
|
left_shift = np.left_shift(10, 2)
|
|
right_shift = np.right_shift(40, 2)
|
|
return Tensor(bitwise_and), Tensor(bitwise_or), Tensor(invert), Tensor(left_shift), Tensor(right_shift)
|
|
|
|
bitwise_and, bitwise_or, invert, left_shift, right_shift = np_bitwise()
|
|
assert bitwise_and.asnumpy() == 1
|
|
assert bitwise_or.asnumpy() == 29
|
|
assert np.all(invert.asnumpy() == np.array([242]))
|
|
assert left_shift.asnumpy() == 40
|
|
assert right_shift.asnumpy() == 10
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_char_1():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy char method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_char():
|
|
char_add = np.char.add(['MindSpore'], [' fallback'])
|
|
char_multiply = np.char.multiply('fallback ', 3)
|
|
char_center = np.char.center('fallback', 10, fillchar='*')
|
|
char_capitalize = np.char.capitalize('fallback')
|
|
char_title = np.char.title('fallback')
|
|
char_lower = np.char.lower('FALLBACK')
|
|
char_upper = np.char.upper('fallback')
|
|
return Tensor(char_add), Tensor(char_multiply), Tensor(char_center), Tensor(char_capitalize), \
|
|
Tensor(char_title), Tensor(char_lower), Tensor(char_upper)
|
|
|
|
char_add, char_multiply, char_center, char_capitalize, char_title, char_lower, char_upper = np_char()
|
|
assert char_add.asnumpy() == 'MindSpore fallback'
|
|
assert char_multiply.asnumpy() == 'fallback fallback fallback '
|
|
assert char_center.asnumpy() == '*fallback*'
|
|
assert char_capitalize.asnumpy() == 'Fallback'
|
|
assert char_title.asnumpy() == 'Fallback'
|
|
assert char_lower.asnumpy() == 'fallback'
|
|
assert char_upper.asnumpy() == 'FALLBACK'
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_char_2():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy char method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_char():
|
|
char_split = np.char.split('MindSpore fallback')
|
|
out_split = np.char.join(' ', char_split)
|
|
|
|
char_splitlines = np.char.splitlines('MindSpore\nfallback')
|
|
out_splitlines = np.char.join(',', char_splitlines)
|
|
|
|
out_strip = np.char.strip('abc acd', 'a')
|
|
out_replace = np.char.replace('faooback', 'oo', 'll')
|
|
char_encode = np.char.encode('runoob', 'cp500')
|
|
out_decode = np.char.decode(char_encode, 'cp500')
|
|
return Tensor(out_split), Tensor(out_splitlines), Tensor(out_strip), Tensor(out_replace), Tensor(out_decode)
|
|
|
|
char_split, char_splitlines, char_strip, char_replace, char_decode = np_char()
|
|
assert char_split.asnumpy() == 'MindSpore fallback'
|
|
assert char_splitlines.asnumpy() == 'MindSpore,fallback'
|
|
assert char_strip.asnumpy() == 'bc acd'
|
|
assert char_replace.asnumpy() == 'fallback'
|
|
assert char_decode.asnumpy() == 'runoob'
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_degree():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_degree():
|
|
out_sin = np.sin(30 * np.pi / 180)
|
|
out_arcsin = np.degrees(np.arcsin(out_sin))
|
|
out_cos = np.cos(60 * np.pi / 180)
|
|
out_arccos = np.degrees(np.arccos(out_cos))
|
|
out_tan = np.tan(45 * np.pi / 180)
|
|
out_arctan = np.degrees(np.arctan(out_tan))
|
|
return Tensor(out_sin), Tensor(out_arcsin), Tensor(out_cos), \
|
|
Tensor(out_arccos), Tensor(out_tan), Tensor(out_arctan)
|
|
|
|
out_sin, out_arcsin, out_cos, out_arccos, out_tan, out_arctan = np_degree()
|
|
assert np.isclose(out_sin.asnumpy(), 0.5)
|
|
assert np.isclose(out_arcsin.asnumpy(), 30)
|
|
assert np.isclose(out_cos.asnumpy(), 0.5)
|
|
assert np.isclose(out_arccos.asnumpy(), 60)
|
|
assert np.isclose(out_tan.asnumpy(), 1)
|
|
assert np.isclose(out_arctan.asnumpy(), 45)
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_math_1():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy math method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_math():
|
|
x = np.array([6, 12])
|
|
y = np.array([3, 5])
|
|
out_add = np.add(x, y)
|
|
out_subtract = np.subtract(x, y)
|
|
out_multiply = np.multiply(x, y)
|
|
out_divide = np.divide(x, y)
|
|
out_mod = np.mod(x, y)
|
|
out_remainder = np.remainder(x, y)
|
|
return Tensor(out_add), Tensor(out_subtract), Tensor(out_multiply), \
|
|
Tensor(out_divide), Tensor(out_mod), Tensor(out_remainder)
|
|
|
|
out_add, out_subtract, out_multiply, out_divide, out_mod, out_remainder = np_math()
|
|
assert np.all(out_add.asnumpy() == np.array([9, 17]))
|
|
assert np.all(out_subtract.asnumpy() == np.array([3, 7]))
|
|
assert np.all(out_multiply.asnumpy() == np.array([18, 60]))
|
|
assert np.allclose(out_divide.asnumpy(), np.array([2, 2.4]))
|
|
assert np.all(out_mod.asnumpy() == np.array([0, 2]))
|
|
assert np.all(out_remainder.asnumpy() == np.array([0, 2]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_math_2():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy math method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_math():
|
|
x = np.array([0.1, 1.4, 2.51, 3.3])
|
|
out_around = np.around(x)
|
|
out_floot = np.floor(x)
|
|
out_ceil = np.ceil(x)
|
|
out_reciprocal = np.reciprocal(np.array([0.25, 1, 2]))
|
|
out_power = np.power(np.array([1.0, 2.0, 3.0]), 2)
|
|
return Tensor(out_around), Tensor(out_floot), Tensor(out_ceil), Tensor(out_reciprocal), Tensor(out_power)
|
|
|
|
out_around, out_floot, out_ceil, out_reciprocal, out_power = np_math()
|
|
assert np.allclose(out_around.asnumpy(), np.array([0, 1, 3, 3]))
|
|
assert np.allclose(out_floot.asnumpy(), np.array([0, 1, 2, 3]))
|
|
assert np.allclose(out_ceil.asnumpy(), np.array([1, 2, 3, 4]))
|
|
assert np.allclose(out_reciprocal.asnumpy(), np.array([4, 1, 0.5]))
|
|
assert np.allclose(out_power.asnumpy(), np.array([1, 4, 9]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_statistic():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy statistic method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_statistic():
|
|
x = np.array([1, 2, 3, 4, 5])
|
|
out_amin = np.amin(x)
|
|
out_amax = np.amax(x)
|
|
out_ptp = np.ptp(x)
|
|
out_percentile = np.percentile(x, 50)
|
|
out_median = np.median(x)
|
|
out_mean = np.mean(x)
|
|
out_average = np.average(x)
|
|
out_sqrt = np.std(x)
|
|
out_var = np.var(x)
|
|
return Tensor(out_amin), Tensor(out_amax), Tensor(out_ptp), Tensor(out_percentile), \
|
|
Tensor(out_median), Tensor(out_mean), Tensor(out_average), Tensor(out_sqrt), Tensor(out_var)
|
|
|
|
out_amin, out_amax, out_ptp, out_percentile, out_median, out_mean, out_average, out_sqrt, out_var = np_statistic()
|
|
assert out_amin.asnumpy() == 1
|
|
assert out_amax.asnumpy() == 5
|
|
assert out_ptp.asnumpy() == 4
|
|
assert np.isclose(out_percentile.asnumpy(), 3.0)
|
|
assert out_median.asnumpy() == 3
|
|
assert out_mean.asnumpy() == 3
|
|
assert out_average.asnumpy() == 3
|
|
assert np.allclose(out_sqrt.asnumpy(), np.array([1.41421356]))
|
|
assert np.isclose(out_var.asnumpy(), 2.0)
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_sort():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_sort():
|
|
x = np.array([3, 1, 2, 4, 5])
|
|
out_sort = np.sort(x)
|
|
out_argsort = np.argsort(x)
|
|
out_argmax = np.argmax(x)
|
|
out_argmin = np.argmin(x)
|
|
out_nonzero = np.nonzero(x)
|
|
out_where = np.where(x > 4)
|
|
return Tensor(out_sort), Tensor(out_argsort), Tensor(out_argmax), \
|
|
Tensor(out_argmin), Tensor(out_nonzero), Tensor(out_where)
|
|
|
|
out_sort, out_argsort, out_argmax, out_argmin, out_nonzero, out_where = np_sort()
|
|
assert np.all(out_sort.asnumpy() == np.array([1, 2, 3, 4, 5]))
|
|
assert np.all(out_argsort.asnumpy() == np.array([1, 2, 0, 3, 4]))
|
|
assert out_argmax.asnumpy() == 4
|
|
assert out_argmin.asnumpy() == 1
|
|
assert np.all(out_nonzero.asnumpy() == np.array([0, 1, 2, 3, 4]))
|
|
assert np.all(out_where.asnumpy() == np.array([4]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_extract():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy extract method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_extract():
|
|
x = np.array([3, 1, 2, 4, 5])
|
|
condition = x % 2 == 0
|
|
out_extract = np.extract(condition, x)
|
|
return Tensor(out_extract)
|
|
|
|
out_extract = np_extract()
|
|
assert np.all(out_extract.asnumpy() == np.array([2, 4]))
|
|
|
|
|
|
@pytest.mark.level0
|
|
@pytest.mark.platform_x86_gpu_training
|
|
@pytest.mark.platform_arm_ascend_training
|
|
@pytest.mark.platform_x86_ascend_training
|
|
@pytest.mark.env_onecard
|
|
def test_np_matrix():
|
|
"""
|
|
Feature: JIT Fallback
|
|
Description: Test numpy matrix method in graph mode.
|
|
Expectation: No exception.
|
|
"""
|
|
@ms_function
|
|
def np_matrix():
|
|
x = np.arange(4).reshape(2, 2)
|
|
y = np.array([[2, 2], [3, 3]])
|
|
out_t = x.T
|
|
out_dot = np.dot(x, y)
|
|
out_vdot = np.vdot(x, y)
|
|
out_inner = np.inner(x, y)
|
|
out_matmul = np.matmul(x, y)
|
|
out_det = np.linalg.det(x)
|
|
out_inv = np.linalg.inv(x)
|
|
return Tensor(out_t), Tensor(out_dot), Tensor(out_vdot), Tensor(out_inner), \
|
|
Tensor(out_matmul), Tensor(out_det), Tensor(out_inv)
|
|
|
|
out_t, out_dot, out_vdot, out_inner, out_matmul, out_det, out_inv = np_matrix()
|
|
assert np.all(out_t.asnumpy() == np.array([[0, 2], [1, 3]]))
|
|
assert np.all(out_dot.asnumpy() == np.array([[3, 3], [13, 13]]))
|
|
assert out_vdot.asnumpy() == 17
|
|
assert np.all(out_inner.asnumpy() == np.array([[2, 3], [10, 15]]))
|
|
assert np.all(out_matmul.asnumpy() == np.array([[3, 3], [13, 13]]))
|
|
assert np.isclose(out_det.asnumpy(), -2.0)
|
|
assert np.allclose(out_inv.asnumpy(), np.array([[-1.5, 0.5], [1, 0]]))
|