From cb67d7d5e672fb83d7bf200fb79b9495a841a30a Mon Sep 17 00:00:00 2001 From: liuxiao93 Date: Tue, 25 Aug 2020 11:46:00 +0800 Subject: [PATCH] Add implicit conversion description for some ops in API. --- mindspore/ops/operations/array_ops.py | 55 +++++++++++++ mindspore/ops/operations/nn_ops.py | 108 +++++++++++++++++++++++++- 2 files changed, 162 insertions(+), 1 deletion(-) diff --git a/mindspore/ops/operations/array_ops.py b/mindspore/ops/operations/array_ops.py index b289e3eb68..c8d21e4dd2 100644 --- a/mindspore/ops/operations/array_ops.py +++ b/mindspore/ops/operations/array_ops.py @@ -2528,6 +2528,11 @@ class ScatterUpdate(_ScatterOp): Using given values to update tensor value, along with the input indices. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: True. @@ -2569,6 +2574,11 @@ class ScatterNdUpdate(_ScatterNdOp): Using given values to update tensor value, along with the input indices. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: True. @@ -2610,6 +2620,11 @@ class ScatterMax(_ScatterOp): Using given values to update tensor value through the max operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: True. @@ -2645,6 +2660,11 @@ class ScatterMin(_ScatterOp): Using given values to update tensor value through the min operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2674,6 +2694,11 @@ class ScatterAdd(_ScatterOp): Using given values to update tensor value through the add operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2703,6 +2728,11 @@ class ScatterSub(_ScatterOp): Using given values to update tensor value through the sub operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2732,6 +2762,11 @@ class ScatterMul(_ScatterOp): Using given values to update tensor value through the mul operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2761,6 +2796,11 @@ class ScatterDiv(_ScatterOp): Using given values to update tensor value through the div operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2790,6 +2830,11 @@ class ScatterNdAdd(_ScatterNdOp): Using given values to update tensor value through the add operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2819,6 +2864,11 @@ class ScatterNdSub(_ScatterNdOp): Using given values to update tensor value through the sub operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether protect the assignment by a lock. Default: False. @@ -2848,6 +2898,11 @@ class ScatterNonAliasingAdd(_ScatterNdOp): Using given values to update tensor value through the add operation, along with the input indices. This operation outputs the `input_x` after the update is done, which makes it convenient to use the updated value. + Inputs of `input_x` and `updates` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **input_x** (Parameter) - The target parameter. The data type should be float16, float32 or int32. - **indices** (Tensor) - The index to do add operation whose data type should be mindspore.int32. diff --git a/mindspore/ops/operations/nn_ops.py b/mindspore/ops/operations/nn_ops.py index 1ccd900b6d..d6de700bf6 100644 --- a/mindspore/ops/operations/nn_ops.py +++ b/mindspore/ops/operations/nn_ops.py @@ -1694,6 +1694,12 @@ class ApplyMomentum(PrimitiveWithInfer): Refer to the paper `On the importance of initialization and momentum in deep learning `_ for more details. + Inputs of `variable`, `accumulation` and `gradient` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + Data type conversion of Parameter is not supported. RuntimeError exception will be thrown. + Args: 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. @@ -3076,6 +3082,11 @@ class FusedSparseAdam(PrimitiveWithInfer): `beta2_power`, :math:`\alpha` represents `learning_rate`, :math:`w` represents `var`, :math:`\epsilon` represents `epsilon`. + All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether to enable a lock to protect updating variable tensors. If true, updates of the var, m, and v tensors will be protected by a lock. @@ -3210,6 +3221,11 @@ class FusedSparseLazyAdam(PrimitiveWithInfer): `beta2_power`, :math:`\alpha` represents `learning_rate`, :math:`w` represents `var`, :math:`\epsilon` represents `epsilon`. + All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): Whether to enable a lock to protect updating variable tensors. If true, updates of the var, m, and v tensors will be protected by a lock. @@ -3325,6 +3341,11 @@ class FusedSparseFtrl(PrimitiveWithInfer): """ Merge the duplicate value of the gradient and then update relevant entries according to the FTRL-proximal scheme. + All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: lr (float): The learning rate value, must be positive. l1 (float): l1 regularization strength, must be greater than or equal to zero. @@ -3423,6 +3444,11 @@ class FusedSparseProximalAdagrad(PrimitiveWithInfer): .. math:: var = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0) + All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): If true, updates of the var and accum tensors will be protected. Default: False. @@ -3669,6 +3695,12 @@ class ApplyAdaMax(PrimitiveWithInfer): :math:`beta_1^t` represent `beta1_power`, :math:`var` represents Variable to be updated, :math:`\epsilon` represents `epsilon`. + Inputs of `var`, `m`, `v` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **var** (Parameter) - Variable to be updated. With float32 or float16 data type. - **m** (Parameter) - The 1st moment vector in the updating formula. Has the same shape and type as `var`. @@ -3791,6 +3823,12 @@ class ApplyAdadelta(PrimitiveWithInfer): .. math:: var -= lr * update + Inputs of `var`, `accum`, `accum_update` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **var** (Parameter) - Weights to be updated. With float32 or float16 data type. - **accum** (Parameter) - Accum to be updated, has the same shape and type as `var`. @@ -3888,6 +3926,12 @@ class ApplyAdagrad(PrimitiveWithInfer): .. math:: var -= lr * grad * \frac{1}{\sqrt{accum}} + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent.. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: update_slots (bool): If `True`, `accum` will be updated. Default: True. @@ -3963,6 +4007,12 @@ class ApplyAdagradV2(PrimitiveWithInfer): .. math:: var -= lr * grad * \frac{1}{\sqrt{accum} + \epsilon} + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: epsilon (float): A small value added for numerical stability. update_slots (bool): If `True`, `accum` will be updated. Default: True. @@ -4040,6 +4090,12 @@ class SparseApplyAdagrad(PrimitiveWithInfer): .. math:: var -= lr * grad * (1 / sqrt(accum)) + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: lr (float): Learning rate. update_slots (bool): If `True`, `accum` will be updated. Default: True. @@ -4119,6 +4175,12 @@ class SparseApplyAdagradV2(PrimitiveWithInfer): .. math:: var -= lr * grad * \frac{1}{\sqrt{accum} + \epsilon} + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: lr (float): Learning rate. epsilon (float): A small value added for numerical stability. @@ -4202,6 +4264,12 @@ class ApplyProximalAdagrad(PrimitiveWithInfer): .. math:: var = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0) + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): If true, updates of the var and accum tensors will be protected. Default: False. @@ -4298,6 +4366,12 @@ class SparseApplyProximalAdagrad(PrimitiveWithInfer): .. math:: var = \frac{sign(\text{prox_v})}{1 + lr * l2} * \max(\left| \text{prox_v} \right| - lr * l1, 0) + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: use_locking (bool): If true, updates of the var and accum tensors will be protected. Default: False. @@ -4311,7 +4385,6 @@ class SparseApplyProximalAdagrad(PrimitiveWithInfer): - **l2** (Union[Number, Tensor]) - l2 regularization strength. should be a float number or a scalar tensor with float16 or float32 data type.. - **grad** (Tensor) - A tensor of the same type as `var`, for the gradient. - The data type must be float16 or float32. - **indices** (Tensor) - A vector of indices into the first dimension of `var` and `accum`. Outputs: @@ -4390,6 +4463,12 @@ class ApplyAddSign(PrimitiveWithInfer): :math:`t` represents updating step while, :math:`m` represents the 1st moment vector, :math:`m_{t-1}` is the last momentent of :math:`m_{t}`, :math:`lr` represents scaling factor `lr`, :math:`g` represents `grad`. + Inputs of `var`, `accum` and `grad` comply with the implicit type conversion rules + to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type. - **m** (Parameter) - Variable tensor to be updated. Has the same dtype as `var`. @@ -4491,6 +4570,13 @@ class ApplyPowerSign(PrimitiveWithInfer): :math:`t` represents updating step while, :math:`m` represents the 1st moment vector, :math:`m_{t-1}` is the last momentent of :math:`m_{t}`, :math:`lr` represents scaling factor `lr`, :math:`g` represents `grad`. + All of inputs comply with the implicit type conversion rules to make the data types consistent. + If `lr`, `logbase`, `sign_decay` or `beta` is a number, the number is automatically converted to Tensor, + and the data type is consistent with the Tensor data type involved in the operation. + If inputs are tensors and have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type. If data type of `var` is float16, all inputs must have the same data type as `var`. @@ -4587,6 +4673,11 @@ class ApplyGradientDescent(PrimitiveWithInfer): .. math:: var = var - \alpha * \delta + Inputs of `var` and `delta` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type. - **alpha** (Union[Number, Tensor]) - Scaling factor, should be a scalar. With float32 or float16 data type. @@ -4649,6 +4740,11 @@ class ApplyProximalGradientDescent(PrimitiveWithInfer): .. math:: var = \frac{sign(\text{prox_v})}{1 + \alpha * l2} * \max(\left| \text{prox_v} \right| - alpha * l1, 0) + Inputs of `var` and `delta` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Inputs: - **var** (Parameter) - Variable tensor to be updated. With float32 or float16 data type. - **alpha** (Union[Number, Tensor]) - Saling factor, should be a scalar. With float32 or float16 data type. @@ -4886,6 +4982,11 @@ class SparseApplyFtrl(PrimitiveWithInfer): """ Update relevant entries according to the FTRL-proximal scheme. + All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: lr (float): The learning rate value, must be positive. l1 (float): l1 regularization strength, must be greater than or equal to zero. @@ -4973,6 +5074,11 @@ class SparseApplyFtrlV2(PrimitiveWithInfer): """ Update relevant entries according to the FTRL-proximal scheme. + All of inputs except `indices` comply with the implicit type conversion rules to make the data types consistent. + If they have different data types, lower priority data type will be converted to + relatively highest priority data type. + RuntimeError exception will be thrown when the data type conversion of Parameter is required. + Args: lr (float): The learning rate value, must be positive. l1 (float): l1 regularization strength, must be greater than or equal to zero.