mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/nn/metrics.py

@@ -0,0 +1,53 @@
+# 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.
+# ============================================================================
+"""
+Metrics from mindspore.train.metrics
+"""
+
+from mindspore.train.metrics import Accuracy, HausdorffDistance, MAE, MSE, Metric, \
+    rearrange_inputs, Precision, Recall, Fbeta, F1, Dice, ROC, auc, \
+    TopKCategoricalAccuracy, Top1CategoricalAccuracy, Top5CategoricalAccuracy, Loss, \
+    MeanSurfaceDistance, RootMeanSquareDistance, BleuScore, CosineSimilarity, \
+    OcclusionSensitivity, Perplexity, ConfusionMatrixMetric, ConfusionMatrix, \
+    names, get_metric_fn, get_metrics
+
+__all__ = [
+    "names",
+    "get_metric_fn",
+    "get_metrics",
+    "Accuracy",
+    "MAE", "MSE",
+    "Metric", "rearrange_inputs",
+    "Precision",
+    "HausdorffDistance",
+    "Recall",
+    "Fbeta",
+    "BleuScore",
+    "CosineSimilarity",
+    "OcclusionSensitivity",
+    "F1",
+    "Dice",
+    "ROC",
+    "auc",
+    "TopKCategoricalAccuracy",
+    "Top1CategoricalAccuracy",
+    "Top5CategoricalAccuracy",
+    "Loss",
+    "MeanSurfaceDistance",
+    "RootMeanSquareDistance",
+    "Perplexity",
+    "ConfusionMatrix",
+    "ConfusionMatrixMetric",
+]

mindspore/nn/optim/_dist_optimizer_registry.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 from inspect import isfunction
 
-from mindspore.parallel._ps_context import _get_ps_context, _is_ps_mode, _enable_distributed_mindrt
+from mindspore.parallel._ps_context import _get_ps_context, _is_ps_mode
 
 
 _create_func_map = {}
@@ -92,7 +92,7 @@ def get_creating_func():
     Returns creating functions for distributed optimizers.
     """
     # Only support optimizers in parameter server mode for now.
-    if _is_ps_mode() and _enable_distributed_mindrt():
+    if _is_ps_mode():
         return create_optimizers_on_pserver
     return no_distributed_optimizer
 

mindspore/nn/optim/ada_grad.py

@@ -16,8 +16,8 @@
 from __future__ import absolute_import
 
 from mindspore.ops import functional as F, composite as C, operations as P
-from mindspore._checkparam import Validator as validator
-from mindspore.common.api import ms_function
+from mindspore import _checkparam as validator
+from mindspore.common.api import jit
 from mindspore.nn.optim.optimizer import Optimizer
 from mindspore.nn.optim.optimizer import opt_init_args_register
 
@@ -53,7 +53,7 @@ class Adagrad(Optimizer):
     The updating Pseudo codes are as follows:
 
     .. math::
-       \begin{aligned} \\
+        \begin{aligned} \\
             &\newline
             &\hline \\
             &\textbf{Parameters}: \text{learning rate } \gamma, \:  \text{ params } w_0, \:
@@ -73,7 +73,7 @@ class Adagrad(Optimizer):
             &\bf{return} \:  w_t \\[-1.ex]
             &\newline
             &\hline \\
-       \end{aligned}
+        \end{aligned}
 
     :math:`state\_sum` stands for the accumulated squared sum of the gradients :math:`accum`.
     :math:`g` stands for `grads`, :math:`\lambda` stands for `weight_decay`.
@@ -112,7 +112,7 @@ class Adagrad(Optimizer):
               If `order_params` in the keys, other keys will be ignored and the element of 'order_params' must be in
               one group of `params`.
 
-        accum (float): The starting value for `h`, must be zero or positive values. Default: 0.1.
+        accum (float): The starting value for :math:`h`, must be zero or positive values. Default: 0.1.
         learning_rate (Union[float, int, Tensor, Iterable, LearningRateSchedule]): Default: 0.001.
 
             - float: The fixed learning rate value. Must be equal to or greater than 0.
@@ -127,7 +127,7 @@ class Adagrad(Optimizer):
             - LearningRateSchedule: Learning rate is dynamic. During training, the optimizer calls the instance of
               LearningRateSchedule with step as the input to get the learning rate of current step.
 
-        update_slots (bool): Whether the `h` will be updated. Default: True.
+        update_slots (bool): Whether the :math:`h` will be updated. Default: True.
         loss_scale (float): Value for the loss scale. It must be greater than 0.0. In general, use the default value.
             Only when `FixedLossScaleManager` is used for training and the `drop_overflow_update` in
             `FixedLossScaleManager` is set to False, then this value needs to be the same as the `loss_scale` in
@@ -159,7 +159,7 @@ class Adagrad(Optimizer):
         ValueError: If `accum` or `weight_decay` is less than 0.
 
     Supported Platforms:
-        ``Ascend`` ``CPU`` ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore as ms
@@ -194,7 +194,7 @@ class Adagrad(Optimizer):
         self.accum = self._parameters.clone(prefix="accum", init=accum)
         self.opt = P.ApplyAdagrad(update_slots=update_slots)
 
-    @ms_function
+    @jit
     def construct(self, grads):
         params = self._parameters
         accum = self.accum

mindspore/nn/optim/adadelta.py

@@ -16,8 +16,7 @@
 from __future__ import absolute_import
 
 from mindspore.ops import functional as F, composite as C, operations as P
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
 from mindspore.common.tensor import Tensor
 from mindspore.nn.optim.optimizer import Optimizer
 from mindspore.nn.optim.optimizer import opt_init_args_register
@@ -37,7 +36,7 @@ def _check_param_value(rho, epsilon, prim_name=None):
     """Check inputs param."""
     validator.check_value_type("rho", rho, [float], prim_name)
     validator.check_value_type("epsilon", epsilon, [float], prim_name)
-    validator.check_float_range(rho, 0.0, 1.0, Rel.INC_BOTH, "rho", prim_name)
+    validator.check_float_range(rho, 0.0, 1.0, validator.INC_BOTH, "rho", prim_name)
     validator.check_non_negative_float(epsilon, "epsilon", prim_name)
 
 

mindspore/nn/optim/adafactor.py

@@ -19,14 +19,13 @@ from mindspore import context
 from mindspore.common import dtype as mstype
 from mindspore.log import logging
 from mindspore.common.initializer import initializer
-from mindspore.common.api import ms_function
+from mindspore.common.api import jit
 from mindspore.ops import operations as P
 from mindspore.ops import composite as C
 from mindspore.ops import functional as F
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator as validator
-from mindspore._checkparam import Rel
+from mindspore import _checkparam as validator
 from mindspore.nn.optim.optimizer import opt_init_args_register
 from mindspore.nn.optim.optimizer import Optimizer
 
@@ -82,13 +81,15 @@ def _run_opt_with_one_number(eps, clip_threshold, beta1, beta2t, weight_decay, s
         exp_avg_sq_row_update = P.Mul()(exp_avg_sq_row_update, beta2t)
         update_mean = reduce_mean_keep_alive(update, -1) * (1.0 - beta2t)
         exp_avg_sq_row_update = P.Add()(exp_avg_sq_row_update, update_mean)
-        exp_avg_sq_row_update = F.assign(exp_avg_sq_row, F.cast(exp_avg_sq_row_update, F.dtype(exp_avg_sq_row)))
+        F.assign(exp_avg_sq_row, F.cast(exp_avg_sq_row_update, F.dtype(exp_avg_sq_row)))
+        exp_avg_sq_row_update = exp_avg_sq_row
 
         exp_avg_sq_col_update = F.cast(exp_avg_sq_col, grad_dtype)
         exp_avg_sq_col_update = P.Mul()(exp_avg_sq_col_update, beta2t)
         update_mean = reduce_mean_keep_alive(update, -2) * (1.0 - beta2t)
         exp_avg_sq_col_update = P.Add()(exp_avg_sq_col_update, update_mean)
-        exp_avg_sq_col_update = F.assign(exp_avg_sq_col, F.cast(exp_avg_sq_col_update, F.dtype(exp_avg_sq_col)))
+        F.assign(exp_avg_sq_col, F.cast(exp_avg_sq_col_update, F.dtype(exp_avg_sq_col)))
+        exp_avg_sq_col_update = exp_avg_sq_col
 
         update = _approx_sq_grad(exp_avg_sq_row_update, exp_avg_sq_col_update)
         update = P.Mul()(update, grad)
@@ -96,7 +97,8 @@ def _run_opt_with_one_number(eps, clip_threshold, beta1, beta2t, weight_decay, s
         exp_avg_sq_update = F.cast(exp_avg_sq, grad_dtype)
         update = update * (1.0 - beta2t)
         exp_avg_sq_update = P.Add()(P.Mul()(exp_avg_sq_update, beta2t), update)
-        exp_avg_sq_update = F.assign(exp_avg_sq, F.cast(exp_avg_sq_update, F.dtype(exp_avg_sq)))
+        F.assign(exp_avg_sq, F.cast(exp_avg_sq_update, F.dtype(exp_avg_sq)))
+        exp_avg_sq_update = exp_avg_sq
         exp_avg_sq_update = 1.0 / P.Sqrt()(exp_avg_sq_update)
         update = P.Mul()(exp_avg_sq_update, grad)
 
@@ -109,7 +111,8 @@ def _run_opt_with_one_number(eps, clip_threshold, beta1, beta2t, weight_decay, s
         if compression:
             exp_avg_update = F.cast(exp_avg, grad_dtype)
         exp_avg_update = P.Add()(P.Mul()(exp_avg_update, beta1), update * (1 - beta1))
-        update = F.assign(exp_avg, F.cast(exp_avg_update, F.dtype(exp_avg)))
+        F.assign(exp_avg, F.cast(exp_avg_update, F.dtype(exp_avg)))
+        update = exp_avg
 
     if weight_decay_flag:
         p_data_fp32_coff = p_data_fp32 * -weight_decay * learning_rate_update
@@ -149,7 +152,7 @@ class AdaFactor(Optimizer):
     Cost <https://arxiv.org/abs/1804.04235>`_.
 
     .. warning::
-        This is an experimental prototype that is subject to change and/or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     Adafactor for weight vector are as follows,
 
@@ -214,7 +217,7 @@ class AdaFactor(Optimizer):
         learning_rate (Union[float, Tensor]): A value or a graph for the learning rate.
             When the learning_rate is a Tensor in a 1D dimension.
             If the type of `learning_rate` is int, it will be converted to float. Default: None.
-        eps (float): The regularization constans for square gradient and parameter scale respectively.
+        eps (tuple): The regularization constans for square gradient and parameter scale respectively.
             default: (1e-30, 1e-3)
         clip_threshold (Union[float, Tensor]): The threshold of root mean square of final gradient update. default: 1.0
         decay_rate (Union[float, Tensor]): The coefficient used to compute running averages of square gradient.
@@ -312,8 +315,8 @@ class AdaFactor(Optimizer):
         validator.check_value_type("clip_threshold", clip_threshold, [float], self.cls_name)
         validator.check_non_negative_float(clip_threshold, "clip_threshold", self.cls_name)
         validator.check_value_type("decay_rate", decay_rate, [float], self.cls_name)
-        validator.check_float_range(decay_rate, 0, 1, Rel.INC_NEITHER, "decay_rate", self.cls_name)
-        validator.check_float_range(weight_decay, 0, 1, Rel.INC_LEFT, "weight_decay", self.cls_name)
+        validator.check_float_range(decay_rate, 0, 1, validator.INC_NEITHER, "decay_rate", self.cls_name)
+        validator.check_float_range(weight_decay, 0, 1, validator.INC_LEFT, "weight_decay", self.cls_name)
         validator.check_value_type("scale_parameter", scale_parameter, [bool], self.cls_name)
         validator.check_value_type("relative_step", relative_step, [bool], self.cls_name)
         validator.check_value_type("compression", compression, [bool], self.cls_name)
@@ -400,11 +403,12 @@ class AdaFactor(Optimizer):
         """
         return False
 
-    @ms_function
+    @jit
     def construct(self, gradients):
         gradients = self.flatten_gradients(gradients)
         lr = self.get_lr()
-        step = F.assign_add(self.step, 1)
+        F.assign_add(self.step, 1)
+        step = self.step
         if self.scale_lr and self.relative_step:
             if self.warmup_init:
                 min_step = 1e-6 * step
@@ -435,7 +439,7 @@ class AdaFactor(Optimizer):
         """
         self._set_base_target(value)
         if value == 'CPU':
-            self.fused_ada_factor.add_prim_attr("primitive_target", "CPU")
+            self.fused_ada_factor.set_device("CPU")
             self.use_fused_ada_factor = True
         else:
             self.use_fused_ada_factor = False