Add TBE op SquaredDifference for VM.

mindspore/ops/_grad/grad_math_ops.py

@@ -252,6 +252,21 @@ def get_bprop_div_no_nan(self):
     return bprop
 
 
+@bprop_getters.register(P.Xdivy)
+def get_bprop_xdivy(self):
+    """Grad definition for `Xdivy` operation."""
+    div_op = P.Xdivy()
+
+    def bprop(x, y, out, dout):
+        x_dtype = F.dtype(x)
+        not_zero_x = F.cast(F.not_equal(x, F.cast(0.0, x_dtype)), x_dtype)
+        bc_x = div_op(not_zero_x, y) * dout
+        bc_y = div_op(-x, F.square(y)) * dout
+        return binop_grad_common(x, y, bc_x, bc_y)
+
+    return bprop
+
+
 @bprop_getters.register(P.Floor)
 def get_bprop_floor(self):
     """Grad definition for `floor` operation."""
@@ -353,6 +368,36 @@ def get_bprop_square(self):
     return bprop
 
 
+@bprop_getters.register(P.SquaredDifference)
+def get_bprop_squared_difference(self):
+    """Grad definition for `SquaredDifference` operation."""
+    neg = P.Neg()
+
+    def bprop(x, y, out, dout):
+        x_grad = 2 * dout * (x - y)
+        bc_x = x_grad
+        bc_y = neg(x_grad)
+        return binop_grad_common(x, y, bc_x, bc_y)
+
+    return bprop
+
+
+@bprop_getters.register(P.Xlogy)
+def get_bprop_xlogy(self):
+    """Grad definition for `Xlogy` operation."""
+    log_op = P.Xlogy()
+    div_op = P.Xdivy()
+
+    def bprop(x, y, out, dout):
+        x_dtype = F.dtype(x)
+        not_zero_x = F.cast(F.not_equal(x, F.cast(0.0, x_dtype)), x_dtype)
+        bc_x = log_op(not_zero_x, y) * dout
+        bc_y = div_op(x, y) * dout
+        return binop_grad_common(x, y, bc_x, bc_y)
+
+    return bprop
+
+
 @bprop_getters.register(P.Sqrt)
 def get_bprop_sqrt(self):
     """Grad definition for `Sqrt` operation."""

mindspore/ops/_op_impl/tbe/__init__.py

@@ -108,6 +108,8 @@ from .elu import _elu_tbe
 from .elu_grad import _elu_grad_tbe
 from .div import _div_tbe
 from .log import _log_tbe
+from .xdivy import _xdivy_tbe
+from .xlogy import _xlogy_tbe
 from .floor_div import _floor_div_tbe
 from .zeros_like import _zeros_like_tbe
 from .neg import _neg_tbe
@@ -133,6 +135,7 @@ from .softplus import _softplus_tbe
 from .softplus_grad import _softplus_grad_tbe
 from .softmax_grad_ext import _softmax_grad_ext_tbe
 from .square import _square_tbe
+from .squared_difference import _squared_difference_tbe
 from .sqrt import _sqrt_tbe
 from .sparse_apply_ftrl_d import _sparse_apply_ftrl_d
 from .sparse_apply_proximal_adagrad import _sparse_apply_proximal_adagrad

mindspore/ops/_op_impl/tbe/squared_difference.py

+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""SquaredDifference op"""
+from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
+
+squared_difference_op_info = TBERegOp("SquaredDifference") \
+    .fusion_type("ELEMWISE") \
+    .async_flag(False) \
+    .binfile_name("squared_difference.so") \
+    .compute_cost(10) \
+    .kernel_name("squared_difference") \
+    .partial_flag(True) \
+    .op_pattern("broadcast") \
+    .input(0, "x1", False, "required", "all") \
+    .input(1, "x2", False, "required", "all") \
+    .output(0, "y", False, "required", "all") \
+    .dtype_format(DataType.I32_None, DataType.I32_None, DataType.I32_None) \
+    .dtype_format(DataType.F16_None, DataType.F16_None, DataType.F16_None) \
+    .dtype_format(DataType.F32_None, DataType.F32_None, DataType.F32_None) \
+    .get_op_info()
+
+
+@op_info_register(squared_difference_op_info)
+def _squared_difference_tbe():
+    """SquaredDifference TBE register"""
+    return

mindspore/ops/_op_impl/tbe/xdivy.py

+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Xdivy op"""
+from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
+
+xdivy_op_info = TBERegOp("Xdivy") \
+    .fusion_type("ELEMWISE") \
+    .async_flag(False) \
+    .binfile_name("xdivy.so") \
+    .compute_cost(10) \
+    .kernel_name("xdivy") \
+    .partial_flag(True) \
+    .input(0, "x1", False, "required", "all") \
+    .input(1, "x2", False, "required", "all") \
+    .output(0, "y", False, "required", "all") \
+    .op_pattern("broadcast") \
+    .dtype_format(DataType.F16_None, DataType.F16_None, DataType.F16_None) \
+    .dtype_format(DataType.F32_None, DataType.F32_None, DataType.F32_None) \
+    .get_op_info()
+
+
+@op_info_register(xdivy_op_info)
+def _xdivy_tbe():
+    """Xdivy TBE register"""
+    return

mindspore/ops/_op_impl/tbe/xlogy.py

+# Copyright 2020 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Xlogy op"""
+from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
+
+xlogy_op_info = TBERegOp("Xlogy") \
+    .fusion_type("ELEMWISE") \
+    .async_flag(False) \
+    .binfile_name("xlogy.so") \
+    .compute_cost(10) \
+    .kernel_name("xlogy") \
+    .partial_flag(True) \
+    .input(0, "x1", False, "required", "all") \
+    .input(1, "x2", False, "required", "all") \
+    .output(0, "y", False, "required", "all") \
+    .op_pattern("broadcast") \
+    .dtype_format(DataType.F16_None, DataType.F16_None, DataType.F16_None) \
+    .dtype_format(DataType.F32_None, DataType.F32_None, DataType.F32_None) \
+    .get_op_info()
+
+
+@op_info_register(xlogy_op_info)
+def _xlogy_tbe():
+    """Xlogy TBE register"""
+    return

mindspore/ops/operations/__init__.py

@@ -51,7 +51,7 @@ from .math_ops import (Abs, ACos, Asin, Asinh, AddN, AccumulateNV2, AssignAdd, A
                        Minimum, Mul, Neg, NMSWithMask, NotEqual,
                        NPUAllocFloatStatus, NPUClearFloatStatus,
                        NPUGetFloatStatus, Pow, RealDiv, IsNan, IsInf, IsFinite, FloatStatus,
-                       Reciprocal, CumSum, HistogramFixedWidth,
+                       Reciprocal, CumSum, HistogramFixedWidth, SquaredDifference, Xdivy, Xlogy,
                        Sin, Sqrt, Rsqrt, BesselI0e, BesselI1e, TruncateDiv, TruncateMod,
                        Square, Sub, TensorAdd, Sign, Round, SquareSumAll, Atan, Atanh, Cosh, Sinh, Eps, Tan)
 
@@ -107,6 +107,9 @@ __all__ = [
     'Rsqrt',
     'Sqrt',
     'Square',
+    'SquaredDifference',
+    'Xdivy',
+    'Xlogy',
     'Conv2D',
     'Flatten',
     'MaxPoolWithArgmax',

mindspore/ops/operations/math_ops.py

@@ -1121,6 +1121,40 @@ class Mul(_MathBinaryOp):
         return None
 
 
+class SquaredDifference(_MathBinaryOp):
+    """
+    Subtracts the second input tensor from the first input tensor element-wise and returns square of it.
+
+    The inputs must be two tensors or one tensor and one scalar.
+    When the inputs are two tensors,
+    both dtypes cannot be bool, and the shapes of them could be broadcast.
+    When the inputs are one tensor and one scalar,
+    the scalar only could be a constant.
+
+    Inputs:
+        - **input_x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is float16, float32, int32 or bool.
+        - **input_y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is
+          float16, float32, int32 or bool.
+
+    Outputs:
+        Tensor, the shape is same as the shape after broadcasting,
+        and the data type is the one with high precision or high digits among the two inputs.
+
+    Examples:
+        >>> input_x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> input_y = Tensor(np.array([2.0, 4.0, 6.0]), mindspore.float32)
+        >>> squared_difference = P.SquaredDifference()
+        >>> squared_difference(input_x, input_y)
+        [1.0, 4.0, 9.0]
+    """
+
+    def infer_dtype(self, x_dtype, y_dtype):
+        valid_type = [mstype.float16, mstype.float32, mstype.int32]
+        return _MathBinaryOp.do_infer_dtype(x_dtype, y_dtype, valid_type, self.name)
+
+
 class Square(PrimitiveWithInfer):
     """
     Returns square of a tensor element-wise.
@@ -1962,6 +1996,72 @@ class Ceil(PrimitiveWithInfer):
         return x_dtype
 
 
+class Xdivy(_MathBinaryOp):
+    """
+    Divide the first input tensor by the second input tensor element-wise. Returns zero when `x` is zero.
+
+    The inputs must be two tensors or one tensor and one scalar.
+    When the inputs are two tensors,
+    both dtypes cannot be bool, and the shapes of them could be broadcast.
+    When the inputs are one tensor and one scalar,
+    the scalar only could be a constant.
+
+    Inputs:
+        - **input_x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is float16, float32 or bool.
+        - **input_y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is float16, float32 or bool.
+
+    Outputs:
+        Tensor, the shape is same as the shape after broadcasting,
+        and the data type is the one with high precision or high digits among the two inputs.
+
+    Examples:
+        >>> input_x = Tensor(np.array([2, 4, -1]), mindspore.float32)
+        >>> input_y = Tensor(np.array([2, 2, 2]), mindspore.float32)
+        >>> xdivy = P.Xdivy()
+        >>> xdivy(input_x, input_y)
+        [1.0, 2.0, -0.5]
+    """
+
+    def infer_dtype(self, x_dtype, y_dtype):
+        return _MathBinaryOp.do_infer_dtype(x_dtype, y_dtype, [mstype.float16, mstype.float32], self.name)
+
+
+class Xlogy(_MathBinaryOp):
+    """
+    Computes first input tensor multiplied by the logarithm of second input tensor element-wise.
+    Returns zero when `x` is zero.
+
+    The inputs must be two tensors or one tensor and one scalar.
+    When the inputs are two tensors,
+    both dtypes cannot be bool, and the shapes of them could be broadcast.
+    When the inputs are one tensor and one scalar,
+    the scalar only could be a constant.
+
+    Inputs:
+        - **input_x** (Union[Tensor, Number, bool]) - The first input is a number or
+          a bool or a tensor whose data type is float16, float32 or bool.
+        - **input_y** (Union[Tensor, Number, bool]) - The second input is a number or
+          a bool when the first input is a tensor or a tensor whose data type is float16, float32 or bool.
+          The value must be positive.
+
+    Outputs:
+        Tensor, the shape is same as the shape after broadcasting,
+        and the data type is the one with high precision or high digits among the two inputs.
+
+    Examples:
+        >>> input_x = Tensor(np.array([-5, 0, 4]), mindspore.float32)
+        >>> input_y = Tensor(np.array([2， 2， 2]), mindspore.float32)
+        >>> xlogy = P.Xlogy()
+        >>> Xlogy(input_x, input_y)
+        [-3.465736, 0.0, 2.7725887]
+    """
+
+    def infer_dtype(self, x_dtype, y_dtype):
+        return _MathBinaryOp.do_infer_dtype(x_dtype, y_dtype, [mstype.float16, mstype.float32], self.name)
+
+
 class Acosh(PrimitiveWithInfer):
     """
     Compute inverse hyperbolic cosine of x element-wise.

mindspore/ops/operations/nn_ops.py

@@ -3205,11 +3205,11 @@ class FusedSparseFtrl(PrimitiveWithInfer):
         use_locking (bool): Use locks for update operation if True . Default: False.
 
     Inputs:
-        - **var** (Parameter): The variable to be updated. The data type must be float32.
-        - **accum** (Parameter): The accum to be updated, must be same type and shape as `var`.
-        - **linear** (Parameter): The linear to be updated, must be same type and shape as `var`.
-        - **grad** (Tensor): A tensor of the same type as `var`, for the gradient.
-        - **indices** (Tensor): A vector of indices into the first dimension of `var` and `accum`. The shape
+        - **var** (Parameter) - The variable to be updated. The data type must be float32.
+        - **accum** (Parameter) - The accum to be updated, must be same type and shape as `var`.
+        - **linear** (Parameter) - The linear to be updated, must be same type and shape as `var`.
+        - **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
+        - **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`. The shape
           of `indices` must be the same as `grad` in first dimension. The type must be int32.
 
     Outputs:
@@ -3300,9 +3300,9 @@ class FusedSparseProximalAdagrad(PrimitiveWithInfer):
     Inputs:
         - **var** (Parameter) - Variable tensor to be updated. The data type must be float32.
         - **accum** (Parameter) - Variable tensor to be updated. Has the same dtype as `var`.
-        - **lr** (Tensor): The learning rate value. The data type must be float32.
-        - **l1** (Tensor): l1 regularization strength. The data type must be float32.
-        - **l2** (Tensor): l2 regularization strength. The data type must be float32.
+        - **lr** (Tensor) - The learning rate value. The data type must be float32.
+        - **l1** (Tensor) - l1 regularization strength. The data type must be float32.
+        - **l2** (Tensor) - l2 regularization strength. The data type must be float32.
         - **grad** (Tensor) - A tensor of the same type as `var`, for the gradient. The data type must be float32.
         - **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`. The data type
           must be int32.
@@ -4670,16 +4670,16 @@ class ApplyFtrl(PrimitiveWithInfer):
         use_locking (bool): Use locks for update operation if True . Default: False.
 
     Inputs:
-        - **var** (Tensor): The variable to be updated.
-        - **accum** (Tensor): The accum to be updated, must be same type and shape as `var`.
-        - **linear** (Tensor): The linear to be updated, must be same type and shape as `var`.
-        - **grad** (Tensor): Gradient.
-        - **lr** (Union[Number, Tensor]): The learning rate value, must be positive. Default: 0.001.
-        - **l1** (Union[Number, Tensor]): l1 regularization strength, must be greater than or equal to zero.
+        - **var** (Tensor) - The variable to be updated.
+        - **accum** (Tensor) - The accum to be updated, must be same type and shape as `var`.
+        - **linear** (Tensor) - The linear to be updated, must be same type and shape as `var`.
+        - **grad** (Tensor) - Gradient.
+        - **lr** (Union[Number, Tensor]) - The learning rate value, must be positive. Default: 0.001.
+        - **l1** (Union[Number, Tensor]) - l1 regularization strength, must be greater than or equal to zero.
           Default: 0.0.
-        - **l2** (Union[Number, Tensor]): l2 regularization strength, must be greater than or equal to zero.
+        - **l2** (Union[Number, Tensor]) - l2 regularization strength, must be greater than or equal to zero.
           Default: 0.0.
-        - **lr_power** (Union[Number, Tensor]): Learning rate power controls how the learning rate decreases
+        - **lr_power** (Union[Number, Tensor]) - Learning rate power controls how the learning rate decreases
           during training, must be less than or equal to zero. Use fixed learning rate if lr_power is zero.
           Default: -0.5.
 
@@ -4760,17 +4760,17 @@ class SparseApplyFtrl(PrimitiveWithInfer):
         use_locking (bool): Use locks for update operation if True . Default: False.
 
     Inputs:
-        - **var** (Parameter): The variable to be updated. The data type must be float32.
-        - **accum** (Parameter): The accum to be updated, must be same type and shape as `var`.
-        - **linear** (Parameter): The linear to be updated, must be same type and shape as `var`.
-        - **grad** (Tensor): A tensor of the same type as `var`, for the gradient.
-        - **indices** (Tensor): A vector of indices into the first dimension of `var` and `accum`.
+        - **var** (Parameter) - The variable to be updated. The data type must be float32.
+        - **accum** (Parameter) - The accum to be updated, must be same type and shape as `var`.
+        - **linear** (Parameter) - The linear to be updated, must be same type and shape as `var`.
+        - **grad** (Tensor) - A tensor of the same type as `var`, for the gradient.
+        - **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`.
           The shape of `indices` must be the same as `grad` in first dimension. The type must be int32.
 
     Outputs:
-        - **var** (Tensor): Tensor, has the same shape and type as `var`.
-        - **accum** (Tensor): Tensor, has the same shape and type as `accum`.
-        - **linear** (Tensor): Tensor, has the same shape and type as `linear`.
+        - **var** (Tensor) - Tensor, has the same shape and type as `var`.
+        - **accum** (Tensor) - Tensor, has the same shape and type as `accum`.
+        - **linear** (Tensor) - Tensor, has the same shape and type as `linear`.
 
     Examples:
         >>> import mindspore
@@ -4858,9 +4858,9 @@ class SparseApplyFtrlV2(PrimitiveWithInfer):
     Outputs:
         Tuple of 3 Tensor, the updated parameters.
 
-        - **var** (Tensor): Tensor, has the same shape and type as `var`.
-        - **accum** (Tensor): Tensor, has the same shape and type as `accum`.
-        - **linear** (Tensor): Tensor, has the same shape and type as `linear`.
+        - **var** (Tensor) - Tensor, has the same shape and type as `var`.
+        - **accum** (Tensor) - Tensor, has the same shape and type as `accum`.
+        - **linear** (Tensor) - Tensor, has the same shape and type as `linear`.
 
     Examples:
         >>> import mindspore

tests/ut/python/ops/test_ops.py

@@ -1013,6 +1013,18 @@ test_case_math_ops = [
         'desc_const': [(0, 3, 1, 2)],
         'desc_inputs': [],
         'skip': ['backward']}),
+    ('Xdivy', {
+        'block': P.Xdivy(),
+        'desc_inputs': [[4, 5], [2, 3, 4, 5]],
+        'desc_bprop': [[2, 3, 4, 5]]}),
+    ('Xlogy', {
+        'block': P.Xlogy(),
+        'desc_inputs': [[4, 5], [2, 3, 4, 5]],
+        'desc_bprop': [[2, 3, 4, 5]]}),
+    ('SquaredDifference', {
+        'block': P.SquaredDifference(),
+        'desc_inputs': [[4, 5], [2, 3, 4, 5]],
+        'desc_bprop': [[2, 3, 4, 5]]}),
     ('Square', {
         'block': P.Square(),
         'desc_inputs': [[4]],