mindspore.ops.operations

Primitive operator classes.

A collection of operators to build nerual networks or computing functions.

• class mindspore.ops.operations.ACos(*args, **kwargs)[source]

• Computes arccosine of input element-wise.

  • Inputs:
  • • input_x (Tensor) - The shape of tensor is

.

• Outputs:
• Tensor, has the same shape as input_x.

Examples

Copy>>> acos = ACos()
>>> X = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), ms.float32)
>>> output = acos(X)

• class mindspore.ops.operations.Abs(*args, **kwargs)[source]

• Returns absolute value of a tensor element-wise.

  • Inputs:
  • • input_x (Tensor) - The input tensor. The shape of tensor is

.

• Outputs:
• Tensor, has the same shape as the input_x.

Examples

Copy>>> input_x = Tensor(np.array([-1.0, 1.0, 0.0]), mindspore.float32)
>>> abs = Abs()
>>> abs(input_x)
[1.0, 1.0, 0.0]

• class mindspore.ops.operations.Adam(*args, **kwargs)[source]
• Updates gradients by Adaptive Moment Estimation (Adam) algorithm.

The Adam algorithm is proposed in Adam: A Method for Stochastic Optimization.

The updating formulas are as follows,

represents the 1st moment vector,

represents the 2nd moment vector,

representsgradient,

represents scaling factor lr,

represent beta1 and beta2,

represents updating step while

and

represent beta1_power andbeta2_power,

represents learning_rate,

represents var,

representsepsilon.

• Parameters

• • use_locking (bool) – Whether to enable a lock to protect updating variable tensors.If True, updating of the var, m, and v tensors will be protected by a lock.If False, the result is unpredictable. Default: False.

  • use_nesterov (bool) – Whether to use Nesterov Accelerated Gradient (NAG) algorithm to update the gradients.If True, updates the gradients using NAG.If False, updates the gradients without using NAG. Default: False.

• Inputs:

• • var (Tensor) - Weights to be updated.

  • m (Tensor) - The 1st moment vector in the updating formula.

  • v (Tensor) - the 2nd moment vector in the updating formula.

  • beta1_power (float) -

in the updating formula.

- 

beta2_power (float) -

in the updating formula.

- 

lr (float) -

in the updating formula.

- 

beta1 (float) - The exponential decay rate for the 1st moment estimates.

- 

beta2 (float) - The exponential decay rate for the 2nd moment estimates.

- 

epsilon (float) - Term added to the denominator to improve numerical stability.

- 

gradient (Tensor) - Gradients.

• Outputs:
• Tensor, has the same shape and data type as var.

• class mindspore.ops.operations.AddN(*args, **kwargs)[source]
• Computes addition of all input tensors element-wise.

All input tensors should have the same shape.

• Inputs:
• • input_x (Union(tuple[Tensor], list[Tensor])) - The input tuple or listis made up of multiple tensors whose dtype is number or bool to be added together.

• Outputs:

• Tensor, has the same shape and dtype as each entry of the input_x.

Examples

Copy>>> class NetAddN(nn.Cell):
>>>     def __init__(self):
>>>         super(NetAddN, self).__init__()
>>>         self.addN = AddN()
>>>
>>>     def construct(self, *z):
>>>         return self.addN(z)
>>>
>>> net = NetAddN()
>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([4, 5, 6]), mindspore.int32)
>>> net(input_x, input_y, input_x, input_y)
Tensor([10, 14, 18], shape=(3,), dtype=mindspore.int32)

• class mindspore.ops.operations.AllGather(*args, **kwargs)[source]
• Gathers tensors from the specified communication group.

Note

Tensor must have the same shape and format in all processes participating in the collective.

• Parameters

• group (str) – The communication group to work on. Default: “hccl_world_group”.

• Raises

• • TypeError – If group is not a string.

  • ValueError – If the local rank id of the calling process in the group is larger than the group’s rank size.

• Inputs:

• • input_x (Tensor) - The shape of tensor is

.

• Outputs:
• Tensor. If the number of devices in the group is N,then the shape of output is

.

Examples

Copy>>> from mindspore.communication.management import init
>>> import mindspore.ops.operations as P
>>> init('nccl')
>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.allgather = P.AllGather(group="nccl_world_group")
>>>
>>>     def construct(self, x):
>>>         return self.allgather(x)
>>>
>>> input_ = Tensor(np.ones([2, 8]).astype(np.float32))
>>> net = Net()
>>> output = net(input_)

• class mindspore.ops.operations.AllReduce(*args, **kwargs)[source]
• Reduces the tensor data across all devices in such a way that all devices will get the same final result.

Note

The operation of AllReduce does not support “prod” currently.The input of AllReduce does not support dtype “Bool”.Tensor must have same shape and format in all processes participating in the collective.

• Parameters

• • op (str) – Specifies an operation used for element-wise reductions,like sum, max, min. Default: ReduceOp.SUM.

  • group (str) – The communication group to work on. Default: “hccl_world_group”.

• Raises

• • TypeError – If any of op and group is not a string or fusion is not a integer or the input’s dtype is bool.

  • ValueError – If op is “prod”

• Inputs:

• • input_x (Tensor) - The shape of tensor is

.

• Outputs:
• Tensor, has the same shape of the input, i.e.,

.The contents depend on the specified operation.

Examples

Copy>>> from mindspore.communication.management import init
>>> import mindspore.ops.operations as P
>>> init('nccl')
>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.allreduce_sum = P.AllReduce(ReduceOp.SUM, group="nccl_world_group")
>>>
>>>     def construct(self, x):
>>>         return self.allreduce_sum(x)
>>>
>>> input_ = Tensor(np.ones([2, 8]).astype(np.float32))
>>> net = Net()
>>> output = net(input_)

• vmimpl(_x)[source]
• Implement by vm mode.

• class mindspore.ops.operations.ApplyMomentum(*args, **kwargs)[source]
• Optimizer that implements the Momentum algorithm.

Refer to the paper On the importance of initialization and momentum in deeplearning for more details.

• Parameters

• • use_locking (bool) – Enable a lock to protect the update of variable and accumlation tensors. Default: False.

  • use_nesterov (bool) – Enable Nesterov momentum. Default: False.

  • gradient_scale (float) – The scale of the gradient. Default: 1.0.

• Inputs:

• • variable (Tensor) - Weights to be updated.

  • accumulation (Tensor) - Accumulated gradient value by moment weight.

  • learning_rate (float) - Learning rate.

  • gradient (Tensor) - Gradients.

  • momentum (float) - Momentum.

• Outputs:

• Tensor, parameters to be updated.

Examples

Copy>>> net = ResNet50()
>>> loss = SoftmaxCrossEntropyWithLogits()
>>> opt = ApplyMomentum(Tensor(np.array([0.001])), Tensor(np.array([0.9])),
                        filter(lambda x: x.requires_grad, net.get_parameters()))
>>> model = Model(net, loss, opt)

• class mindspore.ops.operations.ArgMaxWithValue(*args, **kwargs)[source]
• Calculates maximum value with corresponding index.

Calculates maximum value along with given axis for the input tensor. Returns the maximum values and indices.

Note

In auto_parallel and semi_auto_parallel mode, the first output index can not be used.

• Parameters

• • axis (int) – The dimension to reduce. Default: 0.

  • keep_dims (bool) – Whether to reduce dimension, if true the output will keep same dimension with the input,the output will reduce dimension if false. Default: False.

• Inputs:

• • input_x (Tensor) - The input tensor, can be any dimension. Set the shape of input tensor as

.

• Outputs:
• Tensor, corresponding index and maximum value of input tensor. If keep_dims is true, the output tensors shapeis

. Else, the shape is

.

Examples

Copy>>> input = Tensor(np.random.rand(5))
>>> index, output = ArgMaxWithValue()(input)

• class mindspore.ops.operations.ArgMinWithValue(*args, **kwargs)[source]
• Calculates minimum value with corresponding index, return indices and values.

Calculates minimum value along with given axis for the input tensor. Returns the minimum values and indices.

Note

In auto_parallel and semi_auto_parallel mode, the first output index can not be used.

• Parameters

• • axis (int) – The dimension to reduce. Default: 0.

  • keep_dims (bool) – Whether to reduce dimension, if true the output will keep same dimension as the input,the output will reduce dimension if false. Default: False.

• Inputs:

• • input_x (Tensor) - The input tensor, can be any dimension. Set the shape of input tensor as

.

• Outputs:
• Tensor, corresponding index and minimum value of input tensor. If keep_dims is true, the output tensors shapeis

. Else, the shape is

.

Examples

Copy>>> input = Tensor(np.random.rand(5))
>>> index, output = ArgMinWithValue()(input)

• class mindspore.ops.operations.Argmax(*args, **kwargs)[source]
• Returns the indices of the max value of a tensor across the axis.

If the shape of input tensor is

, the output tensor shape is

.

• Parameters

• • axis (int) – Axis on which Argmax operation applies. Default: -1.

  • output_type (mindspore.dtype) – An optional data type of mindspore.dtype.int32 andmindspore.dtype.int64. Default: mindspore.dtype.int64.

• Inputs:

• • input_x (Tensor) - Input tensor.

• Outputs:

• Tensor, indices of the max value of input tensor across the axis.

Examples

Copy>>> input = Tensor(np.array([2.0, 3.1, 1.2]))
>>> index = Argmax()(input)
>>> assert index == Tensor(1, mindspore.int64)

• class mindspore.ops.operations.Argmin(*args, **kwargs)[source]
• Returns the indices of the min value of a tensor across the axis.

If the shape of input tensor is

, the output tensor shape is

.

• Parameters

• • axis (int) – Axis on which Argmin operation applies. Default: -1.

  • output_type (mindspore.dtype) – An optional data type from: mindspore.dtype.int32,mindspore.dtype.int64. Default: mindspore.dtype.int64.

• Inputs:

• • input_x (Tensor) - Input tensor.

• Outputs:

• Tensor, indices of the min value of input tensor across the axis.

Examples

Copy>>> input = Tensor(np.array([2.0, 3.1, 1.2]))
>>> index = Argmin()(input)
>>> assert index == Tensor(2, mindspore.int64)

• class mindspore.ops.operations.Assign(*args, **kwargs)[source]

• Assign Parameter with a value.

  • Inputs:

  • • variable (Parameter) - The Parameter.

    • value (Tensor) - The value to assign.

  • Outputs:

  • Tensor, has the same type as original variable.

Examples

Copy>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.y = mindspore.Parameter(Tensor([1.0], mindspore.float32), name="y")
>>>
>>>     def construct(self, x):
>>>         Assign()(self.y, x)
>>>         return x
>>> x = Tensor([2.0], mindspore.float32)
>>> net = Net()
>>> net(x)

• class mindspore.ops.operations.AssignAdd(*args, **kwargs)[source]

• Updates a Parameter by adding a value to it.

  • Inputs:

  • • input_x (Parameter) - The Parameter.

    • input_y (Union[scalar, Tensor]) - Has the same shape as input_x.

Examples

Copy>>> class Net(Cell):
>>>     def __init__(self):
>>>         self.AssignAdd = P.AssignAdd()
>>>         self.inputdata = Parameter(initializer(1, [1], mindspore.int64), name="global_step")
>>>
>>>     def construct(self, x):
>>>         self.AssignAdd(self.inputdata, x)
>>>         return self.inputdata
>>>
>>> net = Net()
>>> x = Tensor(np.ones([1]).astype(np.int64)*100)
>>> net(x)

• class mindspore.ops.operations.AssignSub(*args, **kwargs)[source]

• Updates a Parameter by subtracting a value from it.

  • Inputs:

  • • input_x (Parameter) - The Parameter.

    • input_y (Union[scalar, Tensor]) - Has the same shape as input_x.

Examples

Copy>>> class Net(Cell):
>>>     def __init__(self):
>>>         self.AssignSub = P.AssignSub()
>>>         self.inputdata = Parameter(initializer(1, [1], mindspore.int64), name="global_step")
>>>
>>>     def construct(self, x):
>>>         self.AssignSub(self.inputdata, x)
>>>         return self.inputdata
>>>
>>> net = Net()
>>> x = Tensor(np.ones([1]).astype(np.int64)*100)
>>> net(x)

• class mindspore.ops.operations.AvgPool(*args, **kwargs)[source]
• Average pooling operation.

Applies a 2D average pooling over an input Tensor which can be regarded as a composition of 2D input planes.Typically the input is of shape

, AvgPool2d outputsregional average in the

-dimension. Given kernel size

and stride

, the operation is as follows.

• Parameters

• • ksize (Union__[int, tuple[int]__]) – The size of the window to take a average over, that should be a tupleof two int for width and height. Default: 1.

  • stride (Union__[int, tuple[int]__]) – The stride of the window, that should be a tuple of two int forwidth and height. Default: 1.

  • padding (str) – The optional values for pad mode “SAME”, “VALID”. Default: “VALID”.

• Inputs:

• • input (Tensor) - Tensor of shape

.

• Outputs:
• Tensor, with shape

.

• class mindspore.ops.operations.BatchMatMul(*args, **kwargs)[source]
• Computes matrix multiplication between two tensors by batch

result[…, :, :] = tensor(a[…, :, :]) * tensor(b[…, :, :]).

The two input tensors must have same rank and the rank must be 3 at least.

• Parameters

• • transpose_a (bool) – If True, a is transposed on the last two dimensions before multiplication.Default: False.

  • transpose_b (bool) – If True, b is transposed on the last two dimensions before multiplication.Default: False.

• Inputs:

• • input_x (Tensor) - The first tensor to be multiplied. The shape of the tensor is

,where

represents the batch size which can be multidimensional,

and

are thesize of the last two dimensions. If transpose_a is True, its shape should be

.

- 

input_y (Tensor) - The second tensor to be multiplied. The shape of the tensor is

. Iftranspose_b is True, its shape should be

.

• Outputs:
• Tensor, the shape of the output tensor is

.

Examples

Copy>>> input_x = Tensor(np.ones(shape=[2, 4, 1, 3]), mindspore.float32)
>>> input_y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
>>> batmatmul = BatchMatMul()
>>> output = batmatmul(input_x, input_y)
>>>
>>> input_x = Tensor(np.ones(shape=[2, 4, 3, 1]), mindspore.float32)
>>> input_y = Tensor(np.ones(shape=[2, 4, 3, 4]), mindspore.float32)
>>> batmatmul = BatchMatMul(transpose_a=True)
>>> output = batmatmul(input_x, input_y)

• class mindspore.ops.operations.BatchNorm(*args, **kwargs)[source]
• Batch Normalization for input data and updated parameters.

Batch Normalization is widely used in convolutional neural networks. This operationapplies Batch Normalization over input to avoid internal covariate shift as describedin the paper Batch Normalization: Accelerating Deep Network Training by Reducing InternalCovariate Shift. It rescales and recenters thefeatures using a mini-batch of data and the learned parameters which can be describedin the following formula,

where

is scale,

is bias,

is epsilon.

• Parameters

• • is_training (bool) – If is_training is True, mean and variance are computed during training.If is_training is False, they’re loaded from checkpoint during inference. Default: False.

  • epsilon (float) – A small value added for numerical stability. Default: 1e-5.

• Inputs:

• • input_x (Tensor) - Tensor of shape

.

- 

scale (Tensor) - Tensor of shape

.

- 

bias (Tensor) - Tensor of shape

.

- 

mean (Tensor) - Tensor of shape

.

- 

variance (Tensor) - Tensor of shape

.

• Outputs:

• Tuple of 5 Tensor, the normalized inputs and the updated parameters.

  • output_x (Tensor) - The same type and shape as the input_x. The shape is

.

- 

updated_scale (Tensor) - Tensor of shape

.

- 

updated_bias (Tensor) - Tensor of shape

.

- 

reserve_space_1 (Tensor) - Tensor of shape

.

- 

reserve_space_2 (Tensor) - Tensor of shape

.

- 

reserve_space_3 (Tensor) - Tensor of shape

.

• class mindspore.ops.operations.BiasAdd(*args, **kwargs)[source]
• Returns sum of input and bias tensor.

Adds the 1-D bias tensor to the input tensor, and boardcasts the shape on all axisexcept for the channel axis.

• Inputs:
• • input_x (Tensor) - Input value, with shape

or

.

- 

bias (Tensor) - Bias value, with shape

.

• Outputs:
• Tensor, with the same shape and type as input_x.

• class mindspore.ops.operations.BinaryCrossEntropy(*args, **kwargs)[source]
• Computes the Binary Cross Entropy between the target and the output.

Note

Sets input as

, input label as

, output as

.Let,

Then,

• Parameters

• reduction (str) – Specifies the reduction to apply to the output.Its value should be one of ‘none’, ‘mean’, ‘sum’. Default: ‘mean’.

• Inputs:

• • input_x (Tensor) - The input Tensor.

  • input_y (Tensor) - The label Tensor which has same shape as input_x.

  • weight (Tensor, optional) - A rescaling weight applied to the loss of each batch element.And it should have same shape as input_x. Default: None.

• Outputs:

• Tensor or Scalar, if reduction is ‘none’, then output is a tensor and same shape as input_x.Otherwise it is a scalar.

• class mindspore.ops.operations.BoundingBoxDecode(*args, **kwargs)[source]

• Decode bounding boxes locations.

  • Parameters

  • • means (tuple) – The means of deltas calculation. Default: (0.0, 0.0, 0.0, 0.0).

    • stds (tuple) – The standard deviations of deltas calculation. Default: (1.0, 1.0, 1.0, 1.0).

    • max_shape (tuple) – The max size limit for decoding box calculation.

    • wh_ratio_clip (float) – The limit of width and height ratio for decoding box calculation. Default: 0.016.

  • Inputs:

  • • anchor_box (Tensor) - Anchor boxes.

    • deltas (Tensor) - Delta of boxes.

  • Outputs:

  • Tensor, decoded boxes.

Examples

Copy>>> boundingbox_decode = BoundingBoxDecode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0),
                                           max_shape=(768, 1280), wh_ratio_clip=0.016)
>>> bbox = boundingbox_decode(anchor_box, deltas)

• class mindspore.ops.operations.BoundingBoxEncode(*args, **kwargs)[source]

• Encode bounding boxes locations.

  • Parameters

  • • means (tuple) – Means for encoding bounding boxes calculation. Default: (0.0, 0.0, 0.0, 0.0).

    • stds (tuple) – Stds for encoding bounding boxes calculation. Default: (1.0, 1.0, 1.0, 1.0).

  • Inputs:

  • • anchor_box (Tensor) - Anchor boxes.

    • groundtruth_box (Tensor) - Ground truth boxes.

  • Outputs:

  • Tensor, encoded bounding boxes.

Examples

Copy>>> boundingbox_encode = BoundingBoxEncode(means=(0.0, 0.0, 0.0, 0.0), stds=(1.0, 1.0, 1.0, 1.0))
>>> delta_box = boundingbox_encode(anchor_box, groundtruth_box)

• class mindspore.ops.operations.Broadcast(*args, **kwargs)[source]
• Broadcasts the tensor to the whole group.

Note

Tensor must have the same shape and format in all processes participating in the collective.

• Parameters

• • root_rank (int) – Source rank. Required in all processes except the onethat is sending the data.

  • group (str) – The communication group to work on. Default: “hccl_world_group”.

• Inputs:

• • input_x (Tensor) - The shape of tensor is

.

• Outputs:
• Tensor, has the same shape of the input, i.e.,

.The contents depend on the data of the root_rank device.

• Raises
• TypeError – If root_rank is not a integer or group is not a string.

Examples

Copy>>> from mindspore.communication.management import init
>>> import mindspore.ops.operations as P
>>> init('nccl')
>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.broadcast = P.Broadcast(1)
>>>
>>>     def construct(self, x):
>>>         return self.broadcast((x,))
>>>
>>> input_ = Tensor(np.ones([2, 8]).astype(np.float32))
>>> net = Net()
>>> output = net(input_)

• class mindspore.ops.operations.Cast(*args, **kwargs)[source]

• Returns a tensor with the new specified data type.

  • Inputs:
  • • input_x (Union[Tensor, Number]) - The shape of tensor is

.The tensor to be casted.

- 

type (dtype.Number) - The valid data type of the output tensor. Only constant value is allowed.

• Outputs:
• Tensor, the shape of tensor is

, same as input_x.

Examples

Copy>>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
>>> input_x = Tensor(input_np)
>>> type_dst = mindspore.int32
>>> cast = Cast()
>>> result = cast(input_x, type_dst)
>>> expect = input_np.astype(type_dst)

• class mindspore.ops.operations.CheckValid(*args, **kwargs)[source]
• Check bounding box.

Check whether the bounding box cross data and data border.

• Inputs:

• • bboxes (Tensor) - Bounding boxes tensor with shape (N, 4).

  • img_metas (Tensor) - Raw image size information, format (height, width, ratio).

• Outputs:

• Tensor, the valided tensor.

• class mindspore.ops.operations.Concat(*args, **kwargs)[source]
• Concat tensor in specified axis.

Concat input tensors along with the given axis.

Note

The input data is a tuple of tensors. These tensors have the same rank R. Set the given axis as m, and

. Set the number of input tensors as N. For the

-th tensor

hasthe shape

.

is the

-th dimension of the

-th tensor. Then, the output tensor shape is

• Parameters

• axis (int) – The specified axis. Default: 0.

• Inputs:

• • input_x (tuple, list) - Tuple or list of input tensors.

• Outputs:

• Tensor, the shape is

.

Examples

Copy>>> data1 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
>>> data2 = Tensor(np.array([[0, 1], [2, 1]]).astype(np.int32))
>>> op = Concat()
>>> output = op((data1, data2))

• class mindspore.ops.operations.ConcatOffset(*args, **kwargs)[source]
• primitive for computing Concat’s gradient.

• class mindspore.ops.operations.ControlDepend(*args, **kwargs)[source]
• Adds control dependency relation between source and destination operation.

In many cases, we need to control the execution order of operations. ControlDepend is designed for this.ControlDepend will indicate the execution engine to run the operations in specific order. ControlDependtells the engine that the destination operations should depend on the source operation which means the sourceoperations should be executed before the destination.

• Parameters

• depend_mode (int) – Use 0 for normal depend, 1 for depend on operations that used the parameter. Default: 0.

• Inputs:

• • src (Any) - The source input. It can be a tuple of operations output or a single operation output. We donot concern about the input data, but concern about the operation that generates the input data.If depend_mode = 1 is specified and the source input is parameter, we will try to find the operations thatused the parameter as input.

  • dst (Any) - The destination input. It can be a tuple of operations output or a single operation output.We do not concern about the input data, but concern about the operation that generates the input data.If depend_mode = 1 is specified and the source input is parameter, we will try to find the operations thatused the parameter as input.

• Outputs:

• Bool. This operation has no actual data output, it will be used to setup the order of relative operations.

Examples

Copy>>> # In the following example, the data calculation uses original global_step. After the calculation the global
>>> # step should be increased, so the add operation should depend on the data calculation operation.
>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>        super(Net, self).__init__()
>>>         self.global_step = Parameter(initializer(0, [1]), name="global_step")
>>>         self.rate = 0.2
>>>         self.control_depend = ControlDepend()
>>>
>>>     def construct(self, x):
>>>         data = self.rate * self.global_step + x
>>>         added_global_step = self.global_step + 1
>>>         self.global_step = added_global_step
>>>         self.control_depend(data, added_global_step)
>>>         return data

• class mindspore.ops.operations.Conv2D(*args, **kwargs)[source]
• 2D convolution layer.

Applies a 2D convolution over an input tensor which is typically of shape

,where

is batch size and

is channel number. For each batch of shape

, the formula is defined as:

where

is cross correlation operator,

is the input channel number,

rangesfrom

to

,

corresponds to

-th channel of the

-thfilter and

corresponds to the

-th channel of the output.

is a sliceof kernel and it has shape

, where

and

are height and width of the convolution kernel. The full kernel has shape

, where group is the group numberto split the input in the channel dimension.

If the ‘pad_mode’ is set to be “valid”, the output height and width will be

and

respectively.

The first introduction can be found in paper Gradient Based Learning Applied to Document Recognition. More detailed introduction can be found here:http://cs231n.github.io/convolutional-networks/.

• Parameters

• • out_channel (int) – The dimension of the output.

  • kernel_size (Union__[int, tuple[int]__]) – The kernel size of the 2D convolution.

  • mode (int) – 0 Math convolutiuon, 1 cross-correlation convolution ,2 deconvolution, 3 depthwise convolution. Default: 1.

  • pad_mode (str) – “valid”, “same”, “pad” the mode to fill padding. Default: “valid”.

  • pad (int) – The pad value to fill. Default: 0.

  • stride (int) – The stride to apply conv filter. Default: 1.

  • dilation (int) – Specify the space to use between kernel elements. Default: 1.

  • group (int) – Split input into groups. Default: 1.

• Returns

• Tensor, the value that applied 2D convolution.

• Inputs:

• • input (Tensor) - Tensor of shape

.

- 

weight (Tensor) - Set size of kernel is

, then the shape is

.

• Outputs:
• Tensor of shape

.

• class mindspore.ops.operations.Conv2DBackpropInput(*args, **kwargs)[source]

• Computes the gradients of convolution with respect to the input.

  • Parameters

  • • out_channel (int) – The dimensionality of the output space.

    • kernel_size (Union__[int, tuple[int]__]) – The size of the convolution window.

    • pad_mode (str) – “valid”, “same”, “pad” the mode to fill padding. Default: “valid”.

    • pad (int) – The pad value to fill. Default: 0.

    • mode (int) – 0 Math convolutiuon, 1 cross-correlation convolution ,2 deconvolution, 3 depthwise convolution. Default: 1.

    • stride (int) – The stride to apply conv filter. Default: 1.

    • dilation (int) – Specifies the dilation rate to use for dilated convolution. Default: 1.

    • group (int) – Splits input into groups. Default: 1.

  • Returns

  • Tensor, the gradients of convolution.

• class mindspore.ops.operations.Cos(*args, **kwargs)[source]

• Computes cosine of input element-wise.

  • Inputs:
  • • input_x (Tensor) - The shape of tensor is

.

• Outputs:
• Tensor, has the same shape as input_x.

Examples

Copy>>> cos = Cos()
>>> X = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), ms.float32)
>>> output = cos(X)

• class mindspore.ops.operations.CumProd(*args, **kwargs)[source]

• Compute the cumulative product of the tensor x along axis.

  • Parameters

  • • exclusive (bool) – If True, perform exclusive cumulative product. Default: False.

    • reverse (bool) – If True, reverse the result along axis. Default: False

  • Inputs:

  • • input_x (Tensor[Number]) - The input tensor.

    • axis (int) - The dimensions to compute the cumulative product.

  • Outputs:

  • Tensor, has the same shape and dtype as the ‘input_x’.

Examples

Copy>>> data = Tensor(np.array([a, b, c]).astype(np.float32))
>>> op0 = CumProd()
>>> output = op0(data, 0) # output=[a, a * b, a * b * c]
>>> op1 = CumProd(exclusive=True)
>>> output = op1(data, 0) # output=[1, a, a * b]
>>> op2 = CumProd(reverse=True)
>>> output = op2(data, 0) # output=[a * b * c, b * c, c]
>>> op3 = CumProd(exclusive=True, reverse=True)
>>> output = op3(data, 0) # output=[b * c, c, 1]

• class mindspore.ops.operations.CumSum(*args, **kwargs)[source]

• Computes the cumulative sum of input tensor along axis.

  • Parameters

  • • exclusive (bool) – If True, perform exclusive mode. Default: False.

    • reverse (bool) – If True, perform inverse cumulative sum. Default: False.

  • Inputs:

  • • input (Tensor) - The input tensor to accumulate.

    • axis (int) - The axis to accumulate the tensor’s value.

  • Outputs:

  • Tensor, the shape of the output tensor is consistent with the input tensor’s.

Examples

Copy>>> input = Tensor(np.array([[3, 4, 6, 10],[1, 6, 7, 9],[4, 3, 8, 7],[1, 3, 7, 9]]).astype(np.float32))
>>> cumsum = CumSum()
>>> output = cumsum(input, 1)
[[ 3.  7. 13. 23.]
 [ 1.  7. 14. 23.]
 [ 4.  7. 15. 22.]
 [ 1.  4. 11. 20.]]

• class mindspore.ops.operations.DType(*args, **kwargs)[source]

• Returns the data type of input tensor as mindspore.dtype.

  • Inputs:
  • • input_x (Tensor) - The shape of tensor is

.

• Outputs:
• mindspore.dtype, the data type of a tensor.

Examples

Copy>>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
>>> type = DType()(input_tensor)

• class mindspore.ops.operations.DepthToSpace(*args, **kwargs)[source]
• Rearrange blocks of depth data into spatial dimensions.

This is the reverse operation of SpaceToDepth.

The output tensor’s height dimension is

.

The output tensor’s weight dimension is

.

The depth of output tensor is

.

The input tensor’s depth must be divisible by block_size * block_size.The data format is “NCHW”.

• Parameters

• block_size (int) – The block size used to divide depth data. It must be >= 2.

• Inputs:

• • x (Tensor) - The target tensor.

• Outputs:

• Tensor, the same type as x.

Examples

Copy>>> x = Tensor(np.random.rand(1,12,1,1), mindspore.float32)
>>> block_size = 2
>>> op = DepthToSpace(block_size)
>>> output = op(x)
>>> output.asnumpy().shape == (1,3,2,2)

• class mindspore.ops.operations.DepthwiseConv2dNative(*args, **kwargs)[source]
• Returns the depth-wise convolution value for the input.

Applies depthwise conv2d for the input, which will generate more channels with channel_multiplier.Given an input tensor of shape

where

is the batch size and afilter tensor with kernel size

, containing

convolutional filters of depth 1; it applies different filters to each input channel (channel_multiplier channelsfor each with default value 1), then concatenates the results together. The output has

channels.

• Parameters

• • channel_multiplier (int) – The multipiler for the original output conv.

  • kernel_size (int or tuple) – The size of the conv kernel.

  • mode (int) – 0 Math convolution, 1 cross-correlation convolution ,2 deconvolution, 3 depthwise convolution. Default: 3.

  • pad_mode (str) – “valid”, “same”, “pad” the mode to fill padding. Default: “valid”.

  • pad (int) – The pad value to fill. Default: 0.

  • stride (int) – The stride to apply conv filter. Default: 1.

  • dilation (int) – Specifies the dilation rate to use for dilated convolution. Default: 1.

  • group (int) – Splits input into groups. Default: 1.

• Inputs:

• • input (Tensor) - Tensor of shape

.

- 

weight (Tensor) - Set size of kernel is

, then the shape is

.

• Outputs:
• Tensor of shape

.

• class mindspore.ops.operations.Diag(*args, **kwargs)[source]
• Construct a diagonal tensor with a given diagonal values.

Assume input_x has dimensions

, the output is a tensor ofrank 2k with dimensions

where:

and 0 everywhere else.

• Inputs:
• • input_x (Tensor) - The input tensor.

• Outputs:

• Tensor.

Examples

Copy>>> input_x = Tensor([1, 2, 3, 4])
>>> diag = P.Diag()
>>> diag(x)
[[1, 0, 0, 0],
 [0, 2, 0, 0],
 [0, 0, 3, 0],
 [0, 0, 0, 4]]

• class mindspore.ops.operations.DiagPart(*args, **kwargs)[source]
• Extract the diagonal part from given tensor.

Assume input has dimensions

, the output is a tensorof rank k with dimensions

where:

.

• Inputs:
• • input_x (Tensor) - The input Tensor.

• Outputs:

• Tensor.

• Examples

Copy>>> input_x = Tensor([[1, 0, 0, 0],
>>>                   [0, 2, 0, 0],
>>>                   [0, 0, 3, 0],
>>>                   [0, 0, 0, 4]])
>>> diag_part = P.DiagPart()
>>> diag_part(x)
[1, 2, 3, 4]

• class mindspore.ops.operations.Div(*args, **kwargs)[source]
• Computes the quotient of dividing the first input tensor by the second input tensor element-wise.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number]) - The first input is a tensor whose data type is number or a number.

  • input_y (Union[Tensor, Number]) - The second input is a tensor whose data type is same as ‘input_x’ ora number.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is same as ‘input_x’.

• Raises

• ValueError – When input_x and input_y are not the same dtype.

Examples

Copy>>> input_x = Tensor(np.array([-4.0, 5.0, 6.0]), mindspore.float32)
>>> input_y = Tensor(np.array([3.0, 2.0, 3.0]), mindspore.float32)
>>> div = Div()
>>> div(input_x, input_y)
[-2.0, 2.0, 2.0]

• class mindspore.ops.operations.DropoutDoMask(*args, **kwargs)[source]
• Applies dropout mask on the input tensor.

Take the mask output of DropoutGenMask as input, and apply dropout on the input.

• Inputs:

• • input_x (Tensor) - The input tensor.

  • mask (Tensor) - The mask to be applied on input_x, which is the output of DropoutGenMask. And theshape of input_x must be same as the value of DropoutGenMask’s input shape. If input wrong mask,the output of DropoutDoMask are unpredictable.

  • keep_prob (Tensor) - The keep rate, between 0 and 1, e.g. keepprob = 0.9,means dropping out 10% of input units. The value of _keep_prob is same as the input keep_prob ofDropoutGenMask.

• Outputs:

• Tensor, the value that applied dropout on.

Examples

Copy>>> x = Tensor(np.ones([20, 16, 50]), mindspore.float32)
>>> shape = (20, 16, 50)
>>> keep_prob = Tensor(0.5, mindspore.float32)
>>> dropout_gen_mask = DropoutGenMask()
>>> dropout_do_mask = DropoutDoMask()
>>> mask = dropout_gen_mask(shape, keep_prob)
>>> output = dropout_do_mask(x, mask, keep_prob)
>>> assert output.shape() == (20, 16, 50)

• class mindspore.ops.operations.DropoutGenMask(*args, **kwargs)[source]

• Generates the mask value for the input shape.

  • Parameters

  • • Seed0 (int) – Seed0 value for random generating. Default: 0.

    • Seed1 (int) – Seed1 value for random generating. Default: 0.

  • Inputs:

  • • shape (tuple[int]) - The shape of target mask.

    • keep_prob (Tensor) - The keep rate, between 0 and 1, e.g. keep_prob = 0.9,means dropping out 10% of input units.

  • Outputs:

  • Tensor, the value of generated mask for input shape.

Examples

Copy>>> dropout_gen_mask = DropoutGenMask()
>>> shape = (20, 16, 50)
>>> keep_prob = Tensor(0.5, mindspore.float32)
>>> mask = dropout_gen_mask(shape, keep_prob)

• class mindspore.ops.operations.Equal(*args, **kwargs)[source]
• Computes the equivalence between two tensors element-wise.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number, bool]) - The first input is a tensor whose data type is number or bool, ora number or a bool object.

  • input_y (Union[Tensor, Number, bool]) - The second input tensor whose data type is same as ‘input_x’ ora number or a bool object.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is bool.

Examples

Copy>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.float32)
>>> equal = Equal()
>>> equal(input_x, 2.0)
[False, True, False]
>>>
>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([1, 2, 4]), mindspore.int32)
>>> equal = Equal()
>>> equal(input_x, input_y)
[True, True, False]

• class mindspore.ops.operations.EqualCount(*args, **kwargs)[source]
• Computes the number of the same elements of two tensors.

The two input tensors should have same shape.

• Inputs:

• • input_x (Tensor) - The first input tensor.

  • input_y (Tensor) - The second input tensor.

• Outputs:

• Tensor, has the same shape as the input_x.

Examples

Copy>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([1, 2, 4]), mindspore.int32)
>>> equal_count = EqualCount()
>>> equal_count(input_x, input_y)
[2]

• class mindspore.ops.operations.Exp(*args, **kwargs)[source]

• Returns exponential of a tensor element-wise.

  • Inputs:
  • • input_x (Tensor) - The input tensor.

  • Outputs:

  • Tensor, has the same shape as the input_x.

Examples

Copy>>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> exp = Exp()
>>> exp(input_x)
[ 2.71828183,  7.3890561 , 54.59815003]

• class mindspore.ops.operations.ExpandDims(*args, **kwargs)[source]
• Adds an additional dimension at the given axis.

Note

If the specified axis is a negative number, the index is countedbackward from the end and starts at 1.

• Raises

• ValueError – If axis is not an integer or not in the valid range.

• Inputs:

• • input_x (Tensor) - The shape of tensor is

.

- 

axis (int) - Specifies the dimension index at which to expandthe shape of input_x. The value of axis must be in the range[-input_x.dim()-1, input_x.dim()]. Only constant value is allowed.

• Outputs:
• Tensor, the shape of tensor is

if thevalue of axis is 0.

Examples

Copy>>> input_tensor = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
>>> expand_dims = ExpandDims()
>>> output = expand_dims(input_tensor, 0)

• class mindspore.ops.operations.Eye(*args, **kwargs)[source]

• Creates a tensor with ones on the diagonal and zeros elsewhere.

  • Inputs:

  • • n (int) - Number of rows of returned tensor

    • m (int) - Number of columns of returned tensor

    • t (mindspore.dtype) - Mindspore’s dtype, The data type of the returned tensor.

  • Outputs:

  • Tensor, a tensor with ones on the diagonal and zeros elsewhere.

Examples

Copy>>> eye = P.Eye()
>>> out_tensor = eye(2, 2, mindspore.int32)

• class mindspore.ops.operations.Fill(*args, **kwargs)[source]
• Creates a tensor filled with a scalar value.

Creates a tensor with shape described by the first argument and fills it with values in the second argument.

• Inputs:

• • type (mindspore.dtype) - The specified type of output tensor. Only constant value is allowed.

  • shape (tuple) - The specified shape of output tensor. Only constant value is allowed.

  • value (scalar) - Value to fill the returned tensor. Only constant value is allowed.

• Outputs:

• Tensor, has the same type and shape as input value.

Examples

Copy>>> fill = P.Fill()
>>> fill(P.DType()(x), (2, 2), 1)

• class mindspore.ops.operations.Flatten(*args, **kwargs)[source]

• Flattens a tensor without changing its batch size on the 0-th axis.

  • Inputs:
  • • input_x (Tensor) - Tensor of shape

to be flattened.

• Outputs:
• Tensor, the shape of the output tensor is

, where

isthe product of the remaining dimension.

Examples

Copy>>> input_tensor = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
>>> flatten = Flatten()
>>> output = flatten(input_tensor)
>>> assert output.shape() == (1, 24)

• class mindspore.ops.operations.Floor(*args, **kwargs)[source]

• Round a tensor down to the closest integer element-wise.

  • Inputs:
  • • input_x (Tensor) - The input tensor. Its element data type must be float.

  • Outputs:

  • Tensor, has the same shape as input_x.

Examples

Copy>>> input_x = Tensor(np.array([1.1, 2.5, -1.5]), mindspore.float32)
>>> floor = Floor()
>>> floor(input_x)
[1.0, 2.0, -2.0]

• class mindspore.ops.operations.FloorDiv(*args, **kwargs)[source]
• Divide the first input tensor by the second input tensor element-wise and rounds down to the closest integer.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number]) - The first input is a tensor whose data type is number or a number.

  • input_y (Union[Tensor, Number]) - The second input is a tensor whose data type is same as ‘input_x’ ora number.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is same as ‘input_x’.

Examples

Copy>>> input_x = Tensor(np.array([2, 4, -1]), mindspore.int32)
>>> input_y = Tensor(np.array([3, 3, 3]), mindspore.int32)
>>> floor_div = FloorDiv()
>>> floor_div(input_x, input_y)
[0, 1, -1]

• class mindspore.ops.operations.FusedBatchNorm(*args, **kwargs)[source]
• FusedBatchNorm is a BatchNorm that moving mean and moving variance will be computed instead of being loaded.

Batch Normalization is widely used in convolutional networks. This operation appliesBatch Normalization over input to avoid internal covariate shift as described in thepaper Batch Normalization: Accelerating Deep Network Training by Reducing InternalCovariate Shift. It rescales and recenters thefeature using a mini-batch of data and the learned parameters which can be describedin the following formula.

where

is scale,

is bias,

is epsilon.

• Parameters

• • mode (int) – Mode of batch normalization, value is 0 or 1. Default: 0.

  • epsilon (float) – A small value added for numerical stability. Default: 1e-5.

  • momentum (float) – The hyper parameter to compute moving average for running_mean and running_var(e.g.

).Momentum value should be [0, 1]. Default: 0.9.

• Inputs:
• • input_x (Tensor) - Tensor of shape

.

- 

scale (Tensor) - Tensor of shape

.

- 

bias (Tensor) - Tensor of shape

.

- 

mean (Tensor) - Tensor of shape

.

- 

variance (Tensor) - Tensor of shape

.

• Outputs:

• Tuple of 5 Tensor, the normalized input and the updated parameters.

  • output_x (Tensor) - The same type and shape as the input_x.

  • updated_scale (Tensor) - Tensor of shape

.

- 

updated_bias (Tensor) - Tensor of shape

.

- 

updated_moving_mean (Tensor) - Tensor of shape

.

- 

updated_moving_variance (Tensor) - Tensor of shape

.

• class mindspore.ops.operations.GatherNd(*args, **kwargs)[source]
• Gathers slices from a tensor by indices.

Using given indices to gather slices from a tensor with a specified shape.

• Inputs:

• • input_x (Tensor) - The target tensor to gather values.

  • indices (Tensor) - The index tensor.

• Outputs:

• Tensor, has the same type as input_x and the shape is indices_shape[:-1] + x_shape[indices_shape[-1]:].

Examples

Copy>>> input_x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
>>> indices = Tensor(np.array([[0, 0], [1, 1]]), mindspore.int32)
>>> op = GatherNd()
>>> output = op(input_x, indices)

• class mindspore.ops.operations.GatherV2(*args, **kwargs)[source]

• Returns a slice of input tensor based on the specified indices and axis.

  • Inputs:
  • • input_params (Tensor) - The shape of tensor is

.The original Tensor.

- 

input_indices (Tensor) - The shape of tensor is

.Specifies the indices of elements of the original Tensor. Must be in the range[0, input_param.shape()[axis]).

- 

axis (int) - Specifies the dimension index to gather indices.

• Outputs:
• Tensor, the shape of tensor is

.

Examples

Copy>>> params = Tensor(np.array([[1, 2, 7, 42], [3, 4, 54, 22], [2, 2, 55, 3]]), mindspore.float32)
>>> indices = Tensor(np.array([1, 2]), mindspore.int32)
>>> axis = 1
>>> out = GatherV2()(params, indices, axis)

• class mindspore.ops.operations.GeSwitch(*args, **kwargs)[source]
• Adds control switch to data.

Switch data to flow into false or true branch depend on the condition. If the condition is true,the true branch will be activated, or vise verse.

• Inputs:

• • data (Tensor) - The data to be used for switch control.

  • pred (Tensor) - It should be a scalar whose type is bool and shape is (), It is used as condition forswitch control.

• Outputs:

• tuple. Output is tuple(false_output, true_output). The Elements in the tuple has the same shape of input data.The false_output connects with the false_branch and the true_output connects with the true_branch.

Examples

Copy>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.square = P.Square()
>>>         self.add = P.TensorAdd()
>>>         self.value = Tensor(np.full((1), 3, dtype=np.float32))
>>>         self.switch = P.GeSwitch()
>>>         self.merge = P.Merge()
>>>         self.less = P.Less()
>>>
>>>     def construct(self, x, y):
>>>         cond = self.less(x, y)
>>>         st1, sf1 = self.switch(x, cond)
>>>         st2, sf2 = self.switch(y, cond)
>>>         add_ret = self.add(st1, st2)
>>>         st3, sf3 = self.switch(self.value, cond)
>>>         sq_ret = self.square(sf3)
>>>         ret = self.merge((add_ret, sq_ret))
>>>         return ret[0]
>>>
>>> x = Tensor(x_init, dtype=mindspore.float32)
>>> y = Tensor(y_init, dtype=mindspore.float32)
>>> net = Net()
>>> output = net(x, y)

• class mindspore.ops.operations.Gelu(*args, **kwargs)[source]
• Gaussian Error Linear Units activation function.

GeLU is described in the paper Gaussian Error Linear Units (GELUs).And also please refer to BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding..

Defined as follows:

where

is the “Gauss error function” .

• Inputs:
• • input_x (Tensor) - Input to compute the Gelu.

• Outputs:

• Tensor, with the same type and shape as input.

Examples

Copy>>> tensor = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
>>> gelu = Gelu()
>>> result = gelu(tensor)

• class mindspore.ops.operations.GetNext(*args, **kwargs)[source]
• Returns the next element in the dataset queue.

Note

GetNext op needs to be associated with network and also depends on the initdataset interface,it can’t be used directly as a single op.For details, please refer to _nn.cell_wrapper.DataWrapper source code.

• Parameters

• • types (list[mindspore.dtype]) – The type of the outputs.

  • shapes (list[tuple[int]__]) – The dimensionality of the outputs.

  • output_num (int) – The output number, length of types and shapes.

  • shared_name (str) – The queue name of init_dataset interface.

• Inputs:

• No inputs.

• Outputs:

• tuple[Tensor], the output of Dataset. The shape is described in shapes_and the type is described is _types.

Examples

Copy>>> get_next = GetNext([mindspore.float32, mindspore.int32], [[32, 1, 28, 28], [10]], 'shared_name')
>>> feature, label = get_next()

• class mindspore.ops.operations.Greater(*args, **kwargs)[source]
• Computes the boolean value of

element-wise.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number]) - The first input is a tensor whose data type is number or a number.

  • input_y (Union[Tensor, Number]) - The second input is a tensor whose data type is same as ‘input_x’ ora number.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is same as ‘input_x’.

Examples

Copy>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> greater = Greater()
>>> greater(input_x, input_y)
[False, True, False]

• class mindspore.ops.operations.GreaterEqual(*args, **kwargs)[source]
• Computes the boolean value of

element-wise.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number]) - The first input is a tensor whose data type is number or a number.

  • input_y (Union[Tensor, Number]) - The second input is a tensor whose data type is same as ‘input_x’ ora number.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is bool’.

Examples

Copy>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> greater_equal = GreaterEqual()
>>> greater_equal(input_x, input_y)
[True, True, False]

• class mindspore.ops.operations.IOU(*args, **kwargs)[source]
• Calculate intersection over union for boxes.

Calculate the specific value of overlap and union of the boxes.

• Parameters

• mode (string) – The mode is used to specify the calculation method,now support ‘iou’ (intersection over union) or ‘iof’(intersection over foreground) mode. Default: ‘iou’.

• Inputs:

• • anchor_boxes (Tensor) - Anchor boxes, tensor of shape (N, 4).

  • gt_boxes (Tensor) - Ground truth boxes, tensor of shape (M, 4).

• Outputs:

• Tensor, the ‘iou’ values, tensor of shape (M, N).

Examples

Copy>>> iou = IOU()
>>> anchor_boxes = Tensor(np.random.randint(1,5, [10, 4]))
>>> gt_boxes = Tensor(np.random.randint(1,5, [3, 4]))
>>> iou(anchor_boxes, gt_boxes)

• class mindspore.ops.operations.ImageSummary(*args, **kwargs)[source]

• Output image tensor to protocol buffer through image summary operator.

  • Inputs:

  • • name (str) - The name of the input variable.

    • value (Tensor) - The value of image.

Examples

Copy>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.summary = P.ImageSummary()
>>>
>>>     def construct(self, x):
>>>         name = "image"
>>>         out = self.summary(name, x)
>>>         return out

• class mindspore.ops.operations.InsertGradientOf(*args, **kwargs)[source]

• Attach callback to graph node that will be invoked on the node’s gradient.

  • Parameters

  • f (Function) – MindSpore’s Function. Callback function.

  • Inputs:

  • • input_x (Tensor) - The graph node to attach to.

  • Outputs:

  • Tensor, returns input_x directly. InsertGradientOf does not affect the forward result.

Examples

Copy>>> def clip_gradient(dx):
>>>     ret = dx
>>>     if ret > 1.0:
>>>         ret = 1.0
>>>
>>>     if ret < 0.2:
>>>         ret = 0.2
>>>
>>>     return ret
>>>
>>> clip = P.InsertGradientOf(clip_gradient)
>>> def InsertGradientOfClipDemo():
>>>     def clip_test(x, y):
>>>         x = clip(x)
>>>         y = clip(y)
>>>         c = x * y
>>>         return c
>>>
>>>     @ms_function
>>>     def f(x, y):
>>>         return clip_test(x, y)
>>>
>>>     def fd(x, y):
>>>         return C.grad_all(clip_test)(x, y)
>>>
>>>     print("forward: ", f(1.1, 0.1))
>>>     print("clip_gradient:", fd(1.1, 0.1))

• class mindspore.ops.operations.InvertPermutation(*args, **kwargs)[source]
• Computes the inverse of an index permutation.

Given a tuple input, this operation inserts a dimension of 1 at the dimensionThis operation calculates the inverse of the index replacement. It requires a1-dimensional tuple x, which represents the array starting at zero,and swaps each value with its index position. In other words, for the outputtuple y and the input tuple x, this operation calculates the following:

.

Note

These values must include 0. There must be no duplicate values and thevalues can not be negative.

• Inputs:
• • input_x (tuple[int]) - The input tuple is constructed by multipleintegers, i.e.,

representing the indices.The values must include 0. There can be no duplicate values or negative values.

• Outputs:
• tuple[int]. the lenth is same as input.

Examples

Copy>>> invert = InvertPermutation()
>>> input_data = (3, 4, 0, 2, 1)
>>> output = invert(input_data)
>>> output == (2, 4, 3, 0, 1)

• class mindspore.ops.operations.IsInstance(*args, **kwargs)[source]

• Check whether an object is an instance of a target type.

  • Inputs:

  • • inst (Any Object) - The instance to be check. Only constant value is allowed.

    • type_ (mindspore.dtype) - The target type. Only constant value is allowed.

  • Outputs:

  • bool, the check result.

Examples

Copy>>> a = 1
>>> result = IsInstance()(a, mindspore.int32)

• class mindspore.ops.operations.IsSubClass(*args, **kwargs)[source]

• Check whether one type is sub class of another type.

  • Inputs:

  • • sub_type (mindspore.dtype) - The type to be check. Only constant value is allowed.

    • type_ (mindspore.dtype) - The target type. Only constant value is allowed.

  • Outputs:

  • bool, the check result.

Examples

Copy>>> result = IsSubClass()(mindspore.int32,  mindspore.intc)

• class mindspore.ops.operations.L2Normalize(*args, **kwargs)[source]
• L2 normalization Operator.

This operator will normalizes the input using the given axis. The function is shown as follows:

where

is epsilon.

• Parameters

• • axis (int) – The begin axis for the input to apply L2 normalize. Default: 0.

  • epsilon (float) – A small value added for numerical stability. Default: 1e-4.

• Inputs:

• • input_x (Tensor) - Input to compute the normalization.

• Outputs:

• Tensor, with the same type and shape as the input.

• class mindspore.ops.operations.LARSUpdate(*args, **kwargs)[source]

• Conduct lars (layer-wise adaptive rate scaling) update on the square sum of gradient.

  • Parameters

  • • epsilon (float) – Term added to the denominator to improve numerical stability. Default: 1e-05.

    • hyperpara (float) – Trust coefficient for calculating the local learning rate. Default: 0.001.

    • use_clip (bool) – Whether to use clip operation for calculating the local learning rate. Default: False.

  • Inputs:

  • • weight (Tensor) - The weight to be updated.

    • gradient (Tensor) - The gradient of weight, which has the same shape and dtype with weight.

    • norm_weight (Tensor) - A scalar tensor, representing the square sum of weight.

    • norm_gradient (Tensor) - A scalar tensor, representing the square sum of gradient.

    • weight_decay (Union[Number, Tensor]) - Weight decay. It should be a scalar tensor or number.

    • learning_rate (Union[Number, Tensor]) - Learning rate. It should be a scalar tensor or number.

  • Outputs:

  • Tensor, representing the new gradient.

• class mindspore.ops.operations.LSTM(*args, **kwargs)[source]
• Performs the long short term memory(LSTM) on the input.

Detailed information, please refer to nn.LSTM.

• class mindspore.ops.operations.LayerNorm(*args, **kwargs)[source]
• Applies the Layer Normalization to the input tensor.

This operator will normalize the input tensor on given axis. LayerNorm is described in the paperLayer Normalization.

where

is scale,

is bias,

is epsilon.

• Parameters

• • begin_norm_axis (int) – The begin axis of the input_x to apply LayerNorm,the value should be in [-1, rank(input)). Default: 1.

  • begin_params_axis (int) – The begin axis of the parameter input (gamma, beta) toapply LayerNorm, the value should be in [-1, rank(input)). Default: 1.

• Inputs:

• • input_x (Tensor) - Tensor of shape

.The input of LayerNorm.

- 

gamma (Tensor) - Tensor of shape

.The learnable parameter gamma as the scale on norm.

- 

beta (Tensor) - Tensor of shape

.The learnable parameter beta as the scale on norm.

• Outputs:

• tuple[Tensor], tuple of 3 tensors, the normalized input and the updated parameters.

  • output_x (Tensor) - The normalized input, has the same type and shape as the input_x.The shape is

.

- 

updated_gamma (Tensor) - Tensor of shape

.

- 

updated_beta (Tensor) - Tensor of shape

.

• class mindspore.ops.operations.Less(*args, **kwargs)[source]
• Computes the boolean value of

element-wise.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number]) - The first input is a tensor whose data type is number or a number.

  • input_y (Union[Tensor, Number]) - The second input is a tensor whose data type is same as ‘input_x’ ora number.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is bool.

Examples

Copy>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> less = Less()
>>> less(input_x, input_y)
[False, False, True]

• class mindspore.ops.operations.LessEqual(*args, **kwargs)[source]
• Computes the boolean value of

element-wise.

The inputs must be two tensors or one tensor and one scalar.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be same.When the inputs are one tensor and one scalar, the scalar cannot be a parameter, only can be a constant,and the type of the scalar is the same as the data type of the tensor.

• Inputs:

• • input_x (Union[Tensor, Number]) - The first input is a tensor whose data type is number or a number.

  • input_y (Union[Tensor, Number]) - The second input is a tensor whose data type is same as ‘input_x’ ora number.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is bool.

Examples

Copy>>> input_x = Tensor(np.array([1, 2, 3]), mindspore.int32)
>>> input_y = Tensor(np.array([1, 1, 4]), mindspore.int32)
>>> less_equal = LessEqual()
>>> less_equal(input_x, input_y)
[True, False, True]

• class mindspore.ops.operations.Log(*args, **kwargs)[source]

• Returns the natural logarithm of a tensor element-wise.

  • Inputs:
  • • input_x (Tensor) - The input tensor.

  • Outputs:

  • Tensor, has the same shape as the input_x.

Examples

Copy>>> input_x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
>>> log = Log()
>>> log(input_x)
[0.0, 0.69314718, 1.38629436]

• class mindspore.ops.operations.LogSoftmax(*args, **kwargs)[source]
• Log Softmax activation function.

Applies the Log Softmax function to the input tensor on the specified axis.Suppose a slice along the given aixs

then for each element

the Log Softmax function is shown as follows:

where

is the length of the Tensor.

• Parameters

• axis (int) – The axis to do the Log softmax operation. Default: -1.

• Inputs:

• • logits (Tensor) - The input of Log Softmax.

• Outputs:

• Tensor, with the same type and shape as the logits.

• class mindspore.ops.operations.LogicalAnd(*args, **kwargs)[source]
• Computes the “logical AND” of two tensors element-wise.

The inputs must be two tensors or one tensor and one bool object.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be bool.When the inputs are one tensor and one bool object, the bool object cannot be a parameter, only can be a constant,and the data type of the tensor should be bool.

• Inputs:

• • input_x (Union[Tensor, bool]) - The first input is a tensor whose data type is bool or a bool object.

  • input_y (Union[Tensor, bool]) - The second input is a tensor whose data type is bool or a bool object.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is bool.

Examples

Copy>>> input_x = Tensor(np.array([True, False, True]), mindspore.bool_)
>>> input_y = Tensor(np.array([True, True, False]), mindspore.bool_)
>>> logical_and = LogicalAnd()
>>> logical_and(input_x, input_y)
[True, False, False]

• class mindspore.ops.operations.LogicalNot(*args, **kwargs)[source]

• Computes the “logical NOT” of a tensor element-wise.

  • Inputs:
  • • input_x (Tensor) - The input tensor whose dtype is bool

  • Outputs:

  • Tensor, the shape is same as the input_x, and the dtype is bool.

Examples

Copy>>> input_x = Tensor(np.array([True, False, True]), mindspore.bool_)
>>> logical_not = LogicalNot()
>>> logical_not(input_x)
[False, True, False]

• class mindspore.ops.operations.LogicalOr(*args, **kwargs)[source]
• Computes the “logical OR” of two tensors element-wise.

The inputs must be two tensors or one tensor and one bool object.When the inputs are two tensors, the shapes of them could be broadcast,and the data types of them should be bool.When the inputs are one tensor and one bool object, the bool object cannot be a parameter, only can be a constant,and the data type of the tensor should be bool.

• Inputs:

• • input_x (Union[Tensor, bool]) - The first input is a tensor whose data type is bool or a bool object.

  • input_y (Union[Tensor, bool]) - The second input is a tensor whose data type is bool or a bool object.

• Outputs:

• Tensor, the shape is same as the shape after broadcasting, and the data type is bool.

Examples

Copy>>> input_x = Tensor(np.array([True, False, True]), mindspore.bool_)
>>> input_y = Tensor(np.array([True, True, False]), mindspore.bool_)
>>> logical_or = LogicalOr()
>>> logical_or(input_x, input_y)
[True, True, True]

• class mindspore.ops.operations.MakeRefKey(*args, **kwargs)[source]

• Make a RefKey instance by string. RefKey stores the name of Parameter, can be passed through the functions,and used for Assign target.

  • Parameters

  • tag (str) – Parameter name to make the RefKey.

  • Inputs:

  • No input.

  • Outputs:

  • RefKeyType, made from the Parameter name.

Examples

Copy>>> from mindspore.ops import functional as F
>>> class Net(nn.Cell):
>>>     def __init__(self):
>>>         super(Net, self).__init__()
>>>         self.y = Parameter(Tensor(np.ones([6, 8, 10], np.int32)), name="y")
>>>         self.make_ref_key = MakeRefKey("y")
>>>
>>>     def construct(self, x):
>>>         key = self.make_ref_key()
>>>         ref = F.make_ref(key, x, self.y)
>>>         return ref + x
>>>
>>> x = Tensor(np.ones([3, 4, 5], np.int32))
>>> net = Net()
>>> net(x)