Differences with torch.max

torch.max

torch.max(input, dim, keepdim=False, *, out=None)

torch.max(input, other, *, out=None)

For more information, see torch.max.

mindspore.ops.max

mindspore.ops.max(input, axis=None, keepdims=False, *, initial=None, where=None)

For more information, see mindspore.ops.max.

Differences

PyTorch: Output of torch.max(input, dim, keepdim=False, *, out=None) is tuple(max, index of max).

MindSpore: When the axis is None or the shape is empty in MindSpore, the keepdims and subsequent parameters are not effective, and the function is consistent with torch.max(input), and the index returned is fixed at 0. Otherwise, the output is a tuple (max, index of max), which is consistent with torch.max(input, dim, keepdim=False, *, out=None).

Categories	Subcategories	PyTorch	MindSpore	Difference
Parameters	Parameter 1	input	input	Consistent
	Parameter 2	dim	axis	Same function, different parameter names
	Parameter 3	keepdim	keepdims	Same function, different parameter names
	Parameter 4	-	initial	Not involved
	Parameter 5	-	where	Not involved
	Parameter 6	out	-	Not involved

PyTorch: torch.max(input, other, *, out=None) is used in the same way as mindspore.ops.maximum .

Code Example

import mindspore as ms
import mindspore.ops as ops
import torch
import numpy as np

np_x = np.array([[-0.0081, -0.3283, -0.7814, -0.0934],
                 [1.4201, -0.3566, -0.3848, -0.1608],
                 [-0.0446, -0.1843, -1.1348, 0.5722],
                 [-0.6668, -0.2368, 0.2790, 0.0453]]).astype(np.float32)

# torch.max(input, dim, keepdim=False, *, out=None)
input_x = torch.tensor(np_x)
output, index = torch.max(input_x, dim=1)
print(output)
# tensor([-0.0081,  1.4201,  0.5722,  0.2790])
print(index)
# tensor([0, 0, 3, 2])

# mindspore.ops.max
input_x = ms.Tensor(np_x)
output, index = ops.max(input_x, axis=1)
print(output)
# [-0.0081  1.4201  0.5722  0.279 ]
print(index)
# [0 0 3 2]

# torch.max(input, other, *, out=None)
torch_x = torch.tensor([1.0, 5.0, 3.0], dtype=torch.float32)
torch_y = torch.tensor([4.0, 2.0, 6.0], dtype=torch.float32)
torch_output = torch.max(torch_x, torch_y)
print(torch_output)
# tensor([4., 5., 6.])

# mindspore.ops.maximum
x = ms.Tensor([1.0, 5.0, 3.0], ms.float32)
y = ms.Tensor([4.0, 2.0, 6.0], ms.float32)
output = ms.ops.maximum(x, y)
print(output)
# [4. 5. 6.]