From 24770cd3e8fd975822fb7423acf83cdfd1fec7e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=99=88=E5=BF=97=E9=B9=8F?= <15327059664@163.com> Date: Tue, 3 Dec 2024 16:49:43 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B5=8B=E8=AF=95=E6=8E=A5=E5=8F=A3mindspore.m?= =?UTF-8?q?int.any=E3=80=81mindspore.mint.max=E3=80=81mindspore.mint.mean?= =?UTF-8?q?=E3=80=81mindspore.mint.median=E3=80=81mindspore.mint.min?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- test/test_any.py | 122 ++++++++++++++++++++++++++++++++++++++++++ test/test_max.py | 120 +++++++++++++++++++++++++++++++++++++++++ test/test_mean.py | 116 ++++++++++++++++++++++++++++++++++++++++ test/test_median.py | 122 ++++++++++++++++++++++++++++++++++++++++++ test/test_min.py | 127 ++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 607 insertions(+) create mode 100644 test/test_any.py create mode 100644 test/test_max.py create mode 100644 test/test_mean.py create mode 100644 test/test_median.py create mode 100644 test/test_min.py diff --git a/test/test_any.py b/test/test_any.py new file mode 100644 index 0000000..dc881eb --- /dev/null +++ b/test/test_any.py @@ -0,0 +1,122 @@ +import pytest +import numpy as np +import mindspore as ms +from mindspore import mint, Tensor, value_and_grad +import torch + + +dtype_ms = ms.float32 +dtype_torch = torch.float32 +input_data = [[1,0],[0,0],[1,1]] +ms_tensor = Tensor(input_data, dtype_ms) +torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + +def is_same(input_data=[[1,0],[0,0],[1,1]], shape=None, dtype_ms=ms.float32, dtype_torch=torch.float32, dim=-1, keepdim=False): + if shape != None: + input_data = np.random.randn(*shape) + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + ms_result = mint.any(ms_tensor, dim=dim, keepdim=keepdim).asnumpy() + torch_result = torch.any(torch_tensor, dim=dim, keepdim=keepdim).numpy() + + return np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_any_different_dtypes(mode): + """测试random输入不同dtype，对比两个框架的支持度""" + ms.set_context(mode=mode) + ms_dtypes = [ms.int8, ms.int16, ms.int32, ms.int64, ms.uint8,ms.uint16, ms.uint32, ms.uint64, ms.float16, ms.float32, ms.float64, ms.bfloat16, ms.bool_] + torch_dtypes = [torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.uint16, torch.uint32, torch.uint64, torch.float16, torch.float32, torch.float64, torch.bfloat16, torch.bool] + + for i in range(len(ms_dtypes)): + dtype_ms = ms_dtypes[i] + dtype_torch = torch_dtypes[i] + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + err = False + try: + ms_result = mint.any(ms_tensor, dim=1).asnumpy() + except Exception as e: + err = True + print(f"mint.any not supported for {dtype_ms}") + + try: + torch_result = torch.any(torch_tensor, dim=1).numpy() + except Exception as e: + err = True + print(f"torch.any not supported for {dtype_torch}") + + if not err: + assert np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_any_random_input_fixed_dtype(mode): + """测试固定数据类型下的随机输入值，对比输出误差""" + ms.set_context(mode=mode) + + shapes = [[5], [5, 2], [5, 4, 3], [4, 6, 7, 8]] + for i in range(len(shapes)): + shape = shapes[i] + result = is_same(shape=shape) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_any_different_para(mode): + """测试固定shape，固定输入值，不同输入参数（string\bool等类型），两个框架的支持度""" + ms.set_context(mode=mode) + + dims = [None, 0, 1] + keepdims = [True, False] + paras = [(dim, keepdim) for dim in dims for keepdim in keepdims] + + for dim, keepdim in paras: + result = is_same(dim=dim, keepdim=keepdim) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_any_wrong_input(mode): + """测试随机混乱输入，报错信息的准确性""" + ms.set_context(mode=mode) + + try: + ms_result = mint.any(ms_tensor, dim=1, keepdim=1).asnumpy() + except Exception as e: + print(f"keepdim 不是 bool 类型报错信息：\n{e}") + + try: + ms_result = mint.any(input_data, dim=1).asnumpy() + except Exception as e: + print(f"input 不是 Tensor 报错信息：\n{e}") + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_any_forward_back(mode): + """使用Pytorch和MindSpore, 固定输入和权重, 测试正向推理结果和反向梯度""" + ms.set_context(mode=mode) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch, requires_grad=True) + + def forward_pt(x): + return torch.any(x, dim=1, keepdim=False) + + def forward_ms(x): + return mint.any(x, dim=1, keepdim=False) + + grad_fn = value_and_grad(forward_ms) + output_ms, gradient_ms = grad_fn(ms_tensor) + output_pt = forward_pt(torch_tensor) + # output_pt.backward() + # gradient_pt = torch_tensor.grad + assert np.allclose(output_ms.asnumpy(), output_pt.detach().numpy(), atol=1e-3) + # assert np.allclose(gradient_ms.asnumpy(), gradient_pt.numpy(), atol=1e-3) + # print(output_ms, gradient_ms) + # print(output_pt, gradient_pt) + \ No newline at end of file diff --git a/test/test_max.py b/test/test_max.py new file mode 100644 index 0000000..2c69545 --- /dev/null +++ b/test/test_max.py @@ -0,0 +1,120 @@ +import pytest +import numpy as np +import mindspore as ms +from mindspore import mint, Tensor, value_and_grad +import torch + + + +dtype_ms = ms.float32 +dtype_torch = torch.float32 +input_data = [[1, 6, 2, 4],[7, 3, 8, 2],[2, 9, 11, 5]] +ms_tensor = Tensor(input_data, dtype_ms) +torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + +def is_same(input_data=[[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]], shape=None, dtype_ms=ms.float32, dtype_torch=torch.float32, dim=-1, keepdim=False): + if shape != None: + input_data = np.random.randn(*shape) + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + if dim == None: + ms_result = mint.max(ms_tensor) + torch_result = torch.max(torch_tensor) + return np.allclose(ms_result.asnumpy(), torch_result.numpy()) + else: + ms_result, ms_index = mint.max(ms_tensor, dim=dim, keepdim=keepdim) + torch_result, torch_index = torch.max(torch_tensor, dim=dim, keepdim=keepdim) + return np.allclose(ms_result.asnumpy(), torch_result.numpy()) and np.allclose(ms_index.asnumpy(), torch_index.numpy()) + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_max_different_dtypes(mode): + """测试random输入不同dtype，对比两个框架的支持度""" + ms.set_context(mode=mode) + ms_dtypes = [ms.int8, ms.int16, ms.int32, ms.int64, ms.uint8, ms.uint16, ms.uint32, ms.uint64, ms.float16, ms.float32, ms.float64, ms.bfloat16, ms.bool_] + torch_dtypes = [torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.uint16, torch.uint32, torch.uint64, torch.float16, torch.float32, torch.float64, torch.bfloat16, torch.bool] + + for i in range(len(ms_dtypes)): + dtype_ms = ms_dtypes[i] + dtype_torch = torch_dtypes[i] + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + err = False + try: + ms_result = mint.max(ms_tensor).asnumpy() + except Exception as e: + err = True + print(f"mint.max not supported for {dtype_ms}") + # print(e) + + try: + torch_result = torch.max(torch_tensor).numpy() + except Exception as e: + err = True + print(f"torch.max not supported for {dtype_torch}") + # print(e) + + if not err: + assert np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_max_random_input_fixed_dtype(mode): + """测试固定数据类型下的随机输入值，对比输出误差""" + ms.set_context(mode=mode) + + shapes = [[5], [5, 2], [5, 4, 3], [4, 6, 7, 8]] + for i in range(len(shapes)): + shape = shapes[i] + result = is_same(shape=shape) + assert result + + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_max_different_para(mode): + """测试固定shape，固定输入值，不同输入参数（string\bool等类型），两个框架的支持度""" + ms.set_context(mode=mode) + + dims = [None, 0, 1] + keepdims = [True, False] + paras = [(dim, keepdim) for dim in dims for keepdim in keepdims] + for dim, keepdim in paras: + result = is_same(dim=dim, keepdim=keepdim) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_max_wrong_input(mode): + """测试随机混乱输入，报错信息的准确性""" + ms.set_context(mode=mode) + + try: + ms_result = mint.max(ms_tensor, dim=None, keepdim=True).asnumpy() + except Exception as e: + print(f"dim 为 None 且 keepdim 不是 False报错信息：\n{e}") + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_max_forward_back(mode): + """使用Pytorch和MindSpore, 固定输入和权重, 测试正向推理结果和反向梯度""" + ms.set_context(mode=mode) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch, requires_grad=True) + + def forward_pt(x): + return torch.max(x) + + def forward_ms(x): + return mint.max(x, dim=None, keepdim=False) + + grad_fn = value_and_grad(forward_ms) + output_ms, gradient_ms = grad_fn(ms_tensor) + output_pt = forward_pt(torch_tensor) + output_pt.backward() + gradient_pt = torch_tensor.grad + assert np.allclose(output_ms.asnumpy(), output_pt.detach().numpy(), atol=1e-3) + assert np.allclose(gradient_ms.asnumpy(), gradient_pt.numpy(), atol=1e-3) \ No newline at end of file diff --git a/test/test_mean.py b/test/test_mean.py new file mode 100644 index 0000000..93c9490 --- /dev/null +++ b/test/test_mean.py @@ -0,0 +1,116 @@ +import pytest +import numpy as np +import mindspore as ms +from mindspore import mint, Tensor, value_and_grad +import torch + + +dtype_ms = ms.float32 +dtype_torch = torch.float32 +input_data = [[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]] +ms_tensor = Tensor(input_data, dtype_ms) +torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + +def is_same(input_data=[[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]], shape=None, dtype_ms=ms.float32, dtype_torch=torch.float32, dim=-1, keepdim=False): + if shape != None: + input_data = np.random.randn(*shape) + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + ms_result = mint.mean(ms_tensor, dim=dim, keepdim=keepdim).asnumpy() + torch_result = torch.mean(torch_tensor, dim=dim, keepdim=keepdim).numpy() + + return np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_mean_different_dtypes(mode): + """测试random输入不同dtype，对比两个框架的支持度""" + ms.set_context(mode=mode) + ms_dtypes = [ms.float16, ms.float32, ms.float64] + torch_dtypes = [torch.float16, torch.float32, torch.float64] + + for i in range(len(ms_dtypes)): + dtype_ms = ms_dtypes[i] + dtype_torch = torch_dtypes[i] + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + err = False + try: + ms_result = mint.mean(ms_tensor).asnumpy() + except Exception as e: + er = True + print(f"mint.mean not supported for {dtype_ms}") + # print(e) + + try: + torch_result = torch.mean(torch_tensor).numpy() + except Exception as e: + err = True + print(f"torch.mean not supported for {dtype_torch}") + # print(e) + if not err: + assert np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_mean_random_input_fixed_dtype(mode): + """测试固定数据类型下的随机输入值，对比输出误差""" + ms.set_context(mode=mode) + + shapes = [[5], [5, 2], [5, 4, 3], [4, 6, 7, 8]] + for i in range(len(shapes)): + shape = shapes[i] + result = is_same(shape=shape) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_mean_different_para(mode): + """测试固定shape，固定输入值，不同输入参数（string\bool等类型），两个框架的支持度""" + ms.set_context(mode=mode) + + dims = [None, 0, 1] + keepdims = [True, False] + paras = [(dim, keepdim) for dim in dims for keepdim in keepdims] + + for dim, keepdim in paras: + result = is_same(dim=dim, keepdim=keepdim) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_mean_wrong_input(mode): + """测试随机混乱输入，报错信息的准确性""" + ms.set_context(mode=mode) + + try: + ms_result = mint.mean(ms_tensor, dim=2, keepdim=True).asnumpy() + except Exception as e: + print(f"dim 超出范围报错信息：\n{e}") + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_mean_forward_back(mode): + """使用Pytorch和MindSpore, 固定输入和权重, 测试正向推理结果和反向梯度""" + ms.set_context(mode=mode) + + torch_tensor = torch.tensor(input_data, dtype=dtype_torch, requires_grad=True) + + def forward_pt(x): + return torch.mean(x) + + def forward_ms(x): + return mint.mean(x) + + grad_fn = value_and_grad(forward_ms) + output_ms, gradient_ms = grad_fn(ms_tensor) + output_pt = forward_pt(torch_tensor) + output_pt.backward() + gradient_pt = torch_tensor.grad + assert np.allclose(output_ms.asnumpy(), output_pt.detach().numpy(), atol=1e-3) + assert np.allclose(gradient_ms.asnumpy(), gradient_pt.numpy(), atol=1e-3) + \ No newline at end of file diff --git a/test/test_median.py b/test/test_median.py new file mode 100644 index 0000000..5923643 --- /dev/null +++ b/test/test_median.py @@ -0,0 +1,122 @@ +import pytest +import numpy as np +import mindspore as ms +from mindspore import mint, Tensor, value_and_grad +import torch + + +dtype_ms = ms.float32 +dtype_torch = torch.float32 +input_data = [[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]] +ms_tensor = Tensor(input_data, dtype_ms) +torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + +def is_same(input_data=[[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]], shape=None, dtype_ms=ms.float32, dtype_torch=torch.float32, dim=-1, keepdim=False): + if shape != None: + input_data = np.random.randn(*shape) + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + if dim == None: + ms_result = mint.median(ms_tensor) + torch_result = torch.median(torch_tensor) + return np.allclose(ms_result.asnumpy(), torch_result.numpy()) + else: + ms_result, ms_index = mint.median(ms_tensor, dim=dim, keepdim=keepdim) + torch_result, torch_index = torch.median(torch_tensor, dim=dim, keepdim=keepdim) + return np.allclose(ms_result.asnumpy(), torch_result.numpy()) and np.allclose(ms_index.asnumpy(), torch_index.numpy()) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_median_different_dtypes(mode): + """测试random输入不同dtype，对比两个框架的支持度""" + ms.set_context(mode=mode) + ms_dtypes = [ms.int8, ms.int16, ms.int32, ms.int64, ms.uint8, ms.uint16, ms.uint32, ms.uint64, ms.float16, ms.float32, ms.float64, ms.bfloat16, ms.bool_] + torch_dtypes = [torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.uint16, torch.uint32, torch.uint64, torch.float16, torch.float32, torch.float64, torch.bfloat16, torch.bool] + + for i in range(len(ms_dtypes)): + dtype_ms = ms_dtypes[i] + dtype_torch = torch_dtypes[i] + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + err = False + try: + ms_result = mint.median(ms_tensor).asnumpy() + except Exception as e: + err = True + print(f"mint.median not supported for {dtype_ms}") + # print(e) + + try: + torch_result = torch.median(torch_tensor).numpy() + except Exception as e: + err = True + print(f"torch.median not supported for {dtype_torch}") + # print(e) + + if not err: + assert np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_median_random_input_fixed_dtype(mode): + """测试固定数据类型下的随机输入值，对比输出误差""" + ms.set_context(mode=mode) + + shapes = [[5], [5, 2], [5, 4, 3], [4, 6, 7, 8]] + for i in range(len(shapes)): + shape = shapes[i] + result = is_same(shape=shape) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_median_different_para(mode): + """测试固定shape，固定输入值，不同输入参数（string\bool等类型），两个框架的支持度""" + ms.set_context(mode=mode) + + dims = [None, 0, 1] + keepdims = [True, False] + paras = [(dim, keepdim) for dim in dims for keepdim in keepdims] + + for dim, keepdim in paras: + result = is_same(dim=dim, keepdim=keepdim) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_median_wrong_input(mode): + """测试随机混乱输入，报错信息的准确性""" + ms.set_context(mode=mode) + + try: + ms_result = mint.median(ms_tensor, dim=2, keepdim=True).asnumpy() + except Exception as e: + print(f"dim 超出范围报错信息：\n{e}") + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_median_forward_back(mode): + """使用Pytorch和MindSpore, 固定输入和权重, 测试正向推理结果和反向梯度""" + ms.set_context(mode=mode) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch, requires_grad=True) + + def forward_pt(x): + return torch.median(x) + + def forward_ms(x): + return mint.median(x, dim=None, keepdim=False) + + grad_fn = value_and_grad(forward_ms) + output_ms, gradient_ms = grad_fn(ms_tensor) + output_pt = forward_pt(torch_tensor) + output_pt.backward() + gradient_pt = torch_tensor.grad + # print(output_ms.asnumpy(), output_pt.detach().numpy()) + # print(gradient_ms.asnumpy(), gradient_pt.numpy()) + assert np.allclose(output_ms.asnumpy(), output_pt.detach().numpy(), atol=1e-3) + assert np.allclose(gradient_ms.asnumpy(), gradient_pt.numpy(), atol=1e-3) \ No newline at end of file diff --git a/test/test_min.py b/test/test_min.py new file mode 100644 index 0000000..36ae39d --- /dev/null +++ b/test/test_min.py @@ -0,0 +1,127 @@ +import pytest +import numpy as np +import mindspore as ms +from mindspore import mint, Tensor, value_and_grad +import torch + + +dtype_ms = ms.float32 +dtype_torch = torch.float32 +input_data = [[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]] +ms_tensor = Tensor(input_data, dtype_ms) +torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + +def is_same(input_data=[[1,6,2,4],[7,3,8,2],[2, 9, 11, 5]], shape=None, dtype_ms=ms.float32, dtype_torch=torch.float32, dim=-1, keepdim=False): + if shape != None: + input_data = np.random.randn(*shape) + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + if dim == None: + ms_result = mint.min(ms_tensor) + torch_result = torch.min(torch_tensor) + return np.allclose(ms_result.asnumpy(), torch_result.numpy()) + else: + ms_result, ms_index = mint.min(ms_tensor, dim=dim, keepdim=keepdim) + torch_result, torch_index = torch.min(torch_tensor, dim=dim, keepdim=keepdim) + return np.allclose(ms_result.asnumpy(), torch_result.numpy()) and np.allclose(ms_index.asnumpy(), torch_index.numpy()) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_min_different_dtypes(mode): + """测试random输入不同dtype，对比两个框架的支持度""" + ms.set_context(mode=mode) + ms_dtypes = [ms.int8, ms.int16, ms.int32, ms.int64, ms.uint8, ms.uint16, ms.uint32, ms.uint64, ms.float16, ms.float32, ms.float64, ms.bfloat16, ms.bool_] + torch_dtypes = [torch.int8, torch.int16, torch.int32, torch.int64, torch.uint8, torch.uint16, torch.uint32, torch.uint64, torch.float16, torch.float32, torch.float64, torch.bfloat16, torch.bool] + + for i in range(len(ms_dtypes)): + dtype_ms = ms_dtypes[i] + dtype_torch = torch_dtypes[i] + + ms_tensor = Tensor(input_data, dtype_ms) + torch_tensor = torch.tensor(input_data, dtype=dtype_torch) + + err = False + try: + ms_result = mint.min(ms_tensor).asnumpy() + except Exception as e: + err = True + print(f"mint.max not supported for {dtype_ms}") + # print(e) + + try: + torch_result = torch.min(torch_tensor).numpy() + except Exception as e: + err = True + print(f"torch.max not supported for {dtype_torch}") + # print(e) + + if not err: + assert np.allclose(ms_result, torch_result) + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_min_random_input_fixed_dtype(mode): + """测试固定数据类型下的随机输入值，对比输出误差""" + ms.set_context(mode=mode) + + shapes = [[5], [5, 2], [5, 4, 3], [4, 6, 7, 8]] + for i in range(len(shapes)): + shape = shapes[i] + result = is_same(shape=shape) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_min_different_para(mode): + """测试固定shape，固定输入值，不同输入参数（string\bool等类型），两个框架的支持度""" + ms.set_context(mode=mode) + + dims = [None, 0, 1] + keepdims = [True, False] + paras = [(dim, keepdim) for dim in dims for keepdim in keepdims] + + for dim, keepdim in paras: + result = is_same(dim=dim, keepdim=keepdim) + assert result + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_min_wrong_input(mode): + """测试随机混乱输入，报错信息的准确性""" + ms.set_context(mode=mode) + + try: + ms_result = mint.min(ms_tensor, dim=None, keepdim=True).asnumpy() + except Exception as e: + print(f"dim 为 None 且 keepdim 不是 False报错信息：\n{e}") + + +@pytest.mark.parametrize('mode', [ms.GRAPH_MODE, ms.PYNATIVE_MODE]) +def test_min_forward_back(mode): + """使用Pytorch和MindSpore, 固定输入和权重, 测试正向推理结果和反向梯度""" + ms.set_context(mode=mode) + + torch_tensor = torch.tensor(input_data, dtype=dtype_torch, requires_grad=True) + + def forward_pt(x): + return torch.min(x, dim=1, keepdim=False) + + def forward_ms(x): + return mint.min(x, dim=1, keepdim=False) + + grad_fn = value_and_grad(forward_ms) + output_ms, gradient_ms = grad_fn(ms_tensor) + + output_pt = forward_pt(torch_tensor) + for value in output_pt.values: + value.backward(retain_graph=True) + gradient_pt = torch_tensor.grad + + # print(output_ms, output_pt) + # print(gradient_ms, gradient_pt) + assert np.allclose(output_ms[0].asnumpy(), output_pt.values.detach().numpy(), atol=1e-3) + assert np.allclose(output_ms[1].asnumpy(), output_pt.indices.detach().numpy(), atol=1e-3) + assert np.allclose(gradient_ms.asnumpy(), gradient_pt.numpy(), atol=1e-3) \ No newline at end of file