mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.10__cp38-cp38-manylinux1_x86_64.whl

mindspore/train/dataset_helper.py

@@ -18,6 +18,7 @@ from __future__ import absolute_import
 import math
 
 from mindspore import _checkparam as Validator
+from mindspore import log as logger
 from mindspore.common._auto_dynamic import is_auto_dynamic, convert_new_shapes
 from mindspore.common.dtype import pytype_to_dtype
 from mindspore.common.api import _cell_graph_executor
@@ -29,6 +30,7 @@ from mindspore.parallel._utils import _get_device_num, _get_global_rank, _need_t
     _to_full_shapes, _get_pipeline_stages
 from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.ops import operations as P
+from mindspore.common.auto_dynamic_shape import _auto_dynamic_shape
 
 
 def _send_data(dataset, epoch_num):
@@ -50,6 +52,7 @@ def _dynamic_sink_data(dataset, dataset_iter):
     if hasattr(dataset_iter, "sink_size") and \
        dataset_iter.sink_size == 1 and \
        dataset.get_dataset_size() != 1 and \
+       not hasattr(dataset, "__no_send__") and \
        hasattr(dataset_iter, "sink_count") and \
        dataset_iter.sink_count == 1:
         return True
@@ -93,8 +96,7 @@ class _DataWrapper(nn.Cell):
         self.get_next = P.GetNext(
             dataset_types, dataset_shapes, len(dataset_types), queue_name)
         self.network = network
-        if isinstance(network, nn.Cell) and network.jit_config_dict:
-            self._jit_config_dict = network.jit_config_dict
+        self._get_attr_from_cell(network)
 
     def construct(self):
         outputs = self.get_next()
@@ -179,29 +181,20 @@ def _get_dataset_aux(dataset):
 
 def connect_network_with_dataset(network, dataset_helper):
     """
-    Connect the `network` with dataset in `dataset_helper`.
-
-    This function wraps the input network with 'GetNext' so that the data can be fetched automatically from the
-    data channel corresponding to the 'queue_name' and passed to the input network during forward computation.
-
-    Note:
-        In the case of running the network on Ascend/GPU in graph mode, this function will wrap the input network with
-        :class:`mindspore.ops.GetNext`. In other cases, the input network will be returned with no change.
-        The :class:`mindspore.ops.GetNext` is required to get data only in sink mode,
-        so this function is not applicable to no-sink mode.
-        when dataset_helper's dataset_sink_mode is True, it can only be connected to one network.
+    Connect the `network` with dataset in `dataset_helper`. Only supported in `sink mode
+    <https://mindspore.cn/tutorials/experts/en/r2.2/optimize/execution_opt.html>`_, (dataset_sink_mode=True).
 
     Args:
         network (Cell): The training network for dataset.
         dataset_helper (DatasetHelper): A class to process the MindData dataset, it provides the type, shape and queue
-            name of the dataset to wrap the `GetNext`.
+            name of the dataset.
 
     Returns:
-        Cell, a new network wrapped with 'GetNext' in the case of running the task on Ascend in graph mode, otherwise
-        it is the input network.
+        Cell, a new network containing the type, shape and queue name of the dataset info.
 
     Raises:
         RuntimeError: If the API was not called in dataset sink mode.
+
     Supported Platforms:
         ``Ascend`` ``GPU``
 
@@ -215,7 +208,7 @@ def connect_network_with_dataset(network, dataset_helper):
         >>> train_dataset = ds.NumpySlicesDataset(data=data).batch(32)
         >>> dataset_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=True)
         >>> net = nn.Dense(10, 5)
-        >>> net_with_get_next = ms.connect_network_with_dataset(net, dataset_helper)
+        >>> net_with_dataset = ms.connect_network_with_dataset(net, dataset_helper)
     """
     dataset_iter = dataset_helper.iter
     dataset = dataset_iter.dataset
@@ -240,8 +233,10 @@ def connect_network_with_dataset(network, dataset_helper):
     if _dynamic_sink_scenario(dataset, dataset_iter, is_dynamic):
         dataset_types, dataset_shapes = dataset_helper.get_data_info()
         dataset_types = [pytype_to_dtype(x) for x in dataset_types]
-
+        if not is_dynamic:
+            dataset_shapes = _auto_dynamic_shape.auto_dynamic_generate_compile_args(dataset_shapes, True)
         key = str(dataset_types) + str(dataset_shapes)
+        _auto_dynamic_shape.update_phase_and_compile_args(dataset_shapes, key, True, aux)
         if hasattr(aux, '__network_manage__') and key in aux.__network_manage__:
             network = aux.__network_manage__[key]
         else:
@@ -312,7 +307,7 @@ class DatasetHelper:
         >>> for next_element in set_helper:
         ...     # `next_element` includes data and label, using data to run the net
         ...     data = next_element[0]
-        ...     net(data)
+        ...     result = net(data)
     """
 
     def __init__(self, dataset, dataset_sink_mode=True, sink_size=-1, epoch_num=1):
@@ -393,15 +388,15 @@ class DatasetHelper:
         Stop send data about data sink.
 
         Examples:
-            >>> import numpy as np
             >>> import mindspore as ms
-            >>> from mindspore import nn
-            >>> from mindspore import dataset as ds
-            >>>
-            >>> data = {"x": np.float32(np.random.rand(64, 10)), "y": np.random.randint(0, 5, (64,))}
-            >>> train_dataset = ds.NumpySlicesDataset(data=data).batch(32)
-            >>> set_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=False)
-            >>> set_helper.stop_send()
+            >>> import numpy as np
+            >>> # Define a dataset pipeline
+            >>> def generator():
+            ...    for i in range(5):
+            ...        yield (np.ones((32, 10)),)
+            >>> train_dataset = ms.dataset.GeneratorDataset(generator, ["data"])
+            >>> dataset_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=True, sink_size=-1)
+            >>> dataset_helper.stop_send()
         """
         self.iter.stop_send()
 
@@ -417,8 +412,8 @@ class DatasetHelper:
             >>>
             >>> data = {"x": np.float32(np.random.rand(64, 10)), "y": np.random.randint(0, 5, (64,))}
             >>> train_dataset = ds.NumpySlicesDataset(data=data).batch(32)
-            >>> set_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=False)
-            >>> set_helper.release()
+            >>> dataset_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=True)
+            >>> dataset_helper.release()
         """
         self.iter.release()
 
@@ -434,22 +429,63 @@ class DatasetHelper:
             >>>
             >>> data = {"x": np.float32(np.random.rand(64, 10)), "y": np.random.randint(0, 5, (64,))}
             >>> train_dataset = ds.NumpySlicesDataset(data=data).batch(32)
-            >>> set_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=False)
-            >>> set_helper.continue_send()
+            >>> dataset_helper = ms.DatasetHelper(train_dataset, dataset_sink_mode=True)
+            >>> dataset_helper.continue_send()
         """
         self.iter.continue_send()
 
-    def _reset(self, step, epoch):
+    def _reset(self, step, dataset_size):
         """Reset the dataset to the provided step and epoch."""
-        self.iter._reset(step, epoch)  # pylint: disable=protected-access
+        self.iter._reset(step, dataset_size)  # pylint: disable=protected-access
 
+    # pylint: disable=missing-docstring
     def get_data_info(self):
-        """
-        In sink mode, it returns the types and shapes of the current data.
-        Generally, it works in dynamic shape scenarios.
-        """
+        # In sink mode, it returns the types and shapes of the current data.
+        # Generally, it works in dynamic shape scenarios.
         return self.iter.get_data_info()
 
+    # pylint: disable=missing-docstring
+    def get_send_info(self, run_context):
+        # In sink mode, it returns the send information of dataset at this moment.
+        # Send information includes number of send batches, time summary of fetching data on host
+        # and time summary of sending data.
+        class InfoViewer:
+            '''
+            Inner class for parsing send info.
+            '''
+            def __init__(self, send_info, run_context):
+                self.info_ = {}
+                self.sink_size = run_context.original_args()["batch_num"]
+                if run_context.original_args().get("train_dataset", None) is not None:
+                    self.dataset_size = run_context.original_args()["train_dataset"].get_dataset_size()
+                elif run_context.original_args().get("valid_dataset", None) is not None:
+                    self.dataset_size = run_context.original_args()["valid_dataset"].get_dataset_size()
+                else:
+                    raise RuntimeError("Could not find a proper dataset to estimate dataset size.")
+                if not send_info:
+                    epoch = 1
+                    self.info_[epoch] = {'fetch_data_num': 0, 'fetch_data_time': 0, 'first_data_time': 0}
+                else:
+                    for info_per_epoch in send_info:
+                        epoch, fetch_data_num, first_data_time, fetch_data_time = info_per_epoch
+                        if fetch_data_num > 1:
+                            fetch_data_time = (fetch_data_time - first_data_time) / (fetch_data_num - 1) * 1000.
+                        self.info_[epoch] = {'fetch_data_num': fetch_data_num,
+                                             'fetch_data_time': fetch_data_time,
+                                             'first_data_time': first_data_time}
+
+            def epoch(self, epoch):
+                if self.sink_size == self.dataset_size:
+                    return self.info_[epoch]
+                global_step = epoch * self.sink_size
+                data_epoch = math.ceil(global_step / self.dataset_size)
+                return self.info_[data_epoch]
+
+        # send info struct:[epoch, data_num_per_epoch, first_data_time, accumulate_data_time]
+        # for example [1, 1875, 0.421, 0.362]
+        send_info = self.iter.get_send_info()
+        return InfoViewer(send_info, run_context)
+
 
 class _DatasetIter:
     """Base iter for dataset helper"""
@@ -460,6 +496,15 @@ class _DatasetIter:
         self.sink_count = self.get_sink_count(dataset)
         self.dataset_types, self.dataset_shapes = _get_types_and_shapes(
             dataset)
+
+        if dataset.get_init_step() % sink_size != 0:
+            init_epoch = dataset.get_init_step() // sink_size
+            init_step = init_epoch * sink_size
+            logger.warning("Init global step must be the end of the epoch in sink mode, "
+                           "but got: {0}. Reset it to the end of epoch {1} at step {2}."
+                           .format(dataset.get_init_step(), init_epoch, init_step))
+            dataset.set_init_step(init_step)
+
         if not hasattr(dataset, '__transfer_dataset__'):
             if hasattr(dataset, '__loop_size__'):
                 self.sink_size = dataset.__loop_size__
@@ -481,6 +526,7 @@ class _DatasetIter:
         self.release = dataset.__transfer_dataset__.release
         self.continue_send = dataset.__transfer_dataset__.continue_send
         self.get_data_info = dataset.__transfer_dataset__.get_data_info
+        self.get_send_info = dataset.__transfer_dataset__.get_send_info
         if hasattr(dataset.__transfer_dataset__, "_reset"):
             self._reset = dataset.__transfer_dataset__._reset  # pylint: disable=protected-access
 
@@ -517,8 +563,7 @@ class _DatasetIter:
         if hasattr(self.dataset, '__loop_size__'):
             sink_size = self.dataset.__loop_size__
         else:
-            if context.get_context("enable_ge") or context.get_context("device_target") == "Ascend" \
-                    or context.get_context("device_target") == "GPU":
+            if context.get_context("device_target") == "Ascend" or context.get_context("device_target") == "GPU":
                 if self.sink_size > 0:
                     sink_size = self.sink_size
                 else:
@@ -526,24 +571,6 @@ class _DatasetIter:
         return sink_size
 
 
-class _DatasetIterGE(_DatasetIter):
-    """Iter for GE."""
-
-    def __init__(self, dataset, sink_size, epoch_num):
-        super().__init__(dataset, sink_size, epoch_num)
-        self.sink_count = self.get_sink_count(dataset)
-        batch_expand_num = 1
-        if _need_to_full():
-            batch_expand_num = _get_device_num() // _get_pipeline_stages()
-        tensor_list_run = _construct_tensor_list(
-            self.dataset_types, self.dataset_shapes, batch_expand_num)
-
-        def op():
-            return tensor_list_run
-
-        self.op = op
-
-
 class _DatasetIterPyNative(_DatasetIter):
     """Iter for context (mode=PYNATIVE_MODE)."""
 

mindspore/train/loss_scale_manager.py

@@ -62,7 +62,7 @@ class FixedLossScaleManager(LossScaleManager):
         >>> from mindspore import amp, nn
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_scale = 1024.0
         >>> loss_scale_manager = amp.FixedLossScaleManager(loss_scale, False)
@@ -136,7 +136,7 @@ class DynamicLossScaleManager(LossScaleManager):
         >>> from mindspore import amp, nn
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_scale_manager = amp.DynamicLossScaleManager()
         >>> optim = nn.Momentum(params=net.trainable_params(), learning_rate=0.1, momentum=0.9)

mindspore/train/metrics/__init__.py

@@ -109,9 +109,9 @@ def names():
         >>> import mindspore as ms
         >>> ms.train.names()
         ['F1', 'acc', 'accuracy', 'auc', 'bleu_score', 'confusion_matrix', 'confusion_matrix_metric',
-        'cosine_similarity', 'dice', 'hausdorff_distance', 'loss', 'mae', 'mean_surface_distance', 'mase',
-        'occlusion_sensitivity', 'perplexity', 'recall', 'roc', 'root_mean_square_distance', 'top_1_accuracy',
-        'top_5_accuracy', 'topk']
+        'cosine_similarity', 'dice', 'hausdorff_distance', 'loss', 'mae', 'mean_surface_distance', 'mse',
+        'occlusion_sensitivity', 'perplexity', 'precision', 'recall', 'roc', 'root_mean_square_distance',
+        'top_1_accuracy', 'top_5_accuracy', 'topk']
     """
     return sorted(__factory__.keys())
 

mindspore/train/metrics/cosine_similarity.py

@@ -27,7 +27,7 @@ class CosineSimilarity(Metric):
 
     Args:
         similarity (str): 'dot' or 'cosine'. Default: ``'cosine'`` .
-        reduction (str): 'none', 'sum', 'mean' (all along dim -1). Default: ``'none'`` .
+        reduction (str): ``'none'``, 'sum', ``'mean'`` (all along dim -1). Default: ``'none'`` .
         zero_diagonal (bool): If True,  diagonals of results will be set to zero. Default: ``True`` .
 
     Supported Platforms:

mindspore/train/metrics/hausdorff_distance.py

@@ -85,8 +85,8 @@ class HausdorffDistance(Metric):
 
     Args:
         distance_metric (string): Three distance measurement methods are supported:
-                            ``"euclidean"`` , ``"chessboard"`` or
-                            ``"taxicab"`` . Default: ``"euclidean"`` .
+                    ``"euclidean"`` (Euclidean Distance) ,  ``"chessboard"`` (Chessboard Distance, Chebyshev Distance)
+                    or  ``"taxicab"`` (Taxicab Distance, Manhattan Distance). Default: ``"euclidean"`` .
         percentile (float): Floating point numbers between 0 and 100. Specify the percentile parameter to get the
                             percentile of the Hausdorff distance. Default: ``None`` .
         directed (bool): If True, it only calculates h(y_pred, y) distance, otherwise, max(h(y_pred, y), h(y, y_pred))
@@ -112,6 +112,7 @@ class HausdorffDistance(Metric):
         >>> print(mean_average_distance)
         1.4142135623730951
     """
+
     def __init__(self, distance_metric="euclidean", percentile=None, directed=False, crop=True):
         super(HausdorffDistance, self).__init__()
         string_list = ["euclidean", "chessboard", "taxicab"]

mindspore/train/metrics/mean_surface_distance.py

@@ -49,8 +49,9 @@ class MeanSurfaceDistance(Metric):
         \left | S(B) \right |}
 
     Args:
-        distance_metric (string): Three measurement methods are supported: "euclidean", "chessboard" or "taxicab".
-                          Default: ``"euclidean"`` .
+        distance_metric (string): Three measurement methods are supported: ``"euclidean"`` (Euclidean Distance) ,
+                                ``"chessboard"`` (Chessboard Distance, Chebyshev Distance) or
+                                ``"taxicab"`` (Taxicab Distance, Manhattan Distance) Default: ``"euclidean"`` .
         symmetric (bool): Whether to calculate the Mean Surface Distance between y_pred and y.
                           If False, it only calculates :math:`AvgSurDis(y\_pred \rightarrow y)`,
                           otherwise, the mean of  distance from `y_pred` to `y` and from `y` to `y_pred`, i.e.

mindspore/train/metrics/metric.py

@@ -83,6 +83,42 @@ class Metric(metaclass=ABCMeta):
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>>
+        >>> class MyMAE(ms.train.Metric):
+        ...     def __init__(self):
+        ...         super(MyMAE, self).__init__()
+        ...         self.clear()
+        ...
+        ...     def clear(self):
+        ...         self._abs_error_sum = 0
+        ...         self._samples_num = 0
+        ...
+        ...     def update(self, *inputs):
+        ...         y_pred = inputs[0].asnumpy()
+        ...         y = inputs[1].asnumpy()
+        ...         abs_error_sum = np.abs(y - y_pred)
+        ...         self._abs_error_sum += abs_error_sum.sum()
+        ...         self._samples_num += y.shape[0]
+        ...
+        ...     def eval(self):
+        ...         return self._abs_error_sum / self._samples_num
+        >>>
+        >>> x = ms.Tensor(np.array([[0.1, 0.2, 0.6, 0.9], [0.1, 0.2, 0.6, 0.9]]), ms.float32)
+        >>> y = ms.Tensor(np.array([[0.1, 0.1, 0.1, 0.1], [0.1, 0.1, 0.1, 0.1]]), ms.float32)
+        >>> y2 = ms.Tensor(np.array([[0.1, 0.25, 0.7, 0.9], [0.1, 0.25, 0.7, 0.9]]), ms.float32)
+        >>> metric = MyMAE().set_indexes([0, 2])
+        >>> metric.clear()
+        >>> # indexes is [0, 2], using x as logits, y2 as label.
+        >>> metric.update(x, y, y2)
+        >>> accuracy = metric.eval()
+        >>> print(accuracy)
+        1.399999976158142
+        >>> print(metric.indexes)
+        [0, 2]
     """
     def __init__(self):
         self._indexes = None
@@ -133,22 +169,6 @@ class Metric(metaclass=ABCMeta):
 
         Raises:
             ValueError: If the type of input 'indexes'  is not a list or its elements are not all int.
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> from mindspore.train import Accuracy
-            >>>
-            >>> x = Tensor(np.array([[0.2, 0.5], [0.3, 0.1], [0.9, 0.6]]))
-            >>> y = Tensor(np.array([1, 0, 1]))
-            >>> y2 = Tensor(np.array([0, 0, 1]))
-            >>> metric = Accuracy('classification').set_indexes([0, 2])
-            >>> metric.clear()
-            >>> # indexes is [0, 2], using x as logits, y2 as label.
-            >>> metric.update(x, y, y2)
-            >>> accuracy = metric.eval()
-            >>> print(accuracy)
-            0.3333333333333333
         """
         if not isinstance(indexes, list) or not all(isinstance(i, int) for i in indexes):
             raise ValueError("For 'set_indexes', the argument 'indexes' must be a list and all its elements must "
@@ -180,7 +200,7 @@ class Metric(metaclass=ABCMeta):
 
         Tutorial Examples:
             - `Evaluation Metrics - Customized Metrics
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/model/metric.html#customized-metrics>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define clear function to use this base class')
 
@@ -194,7 +214,7 @@ class Metric(metaclass=ABCMeta):
 
         Tutorial Examples:
             - `Evaluation Metrics - Customized Metrics
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/model/metric.html#customized-metrics>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define eval function to use this base class')
 
@@ -211,7 +231,7 @@ class Metric(metaclass=ABCMeta):
 
         Tutorial Examples:
             - `Evaluation Metrics - Customized Metrics
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/model/metric.html#customized-metrics>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/model/metric.html#customized-metrics>`_
         """
         raise NotImplementedError('Must define update function to use this base class')
 

mindspore/train/metrics/roc.py

@@ -172,8 +172,8 @@ class ROC(Metric):
             - **fpr** (np.array) - False positive rate. In binary classification case, a fpr numpy array under different
               thresholds will be returned, otherwise in multiclass case, a list of
               fpr numpy arrays will be returned and each element represents one category.
-            - **tpr** (np.array) - True positive rates. n binary classification case, a tps numpy array under different
-              thresholds will be returned, otherwise in multiclass case, a list of tps numpy arrays
+            - **tpr** (np.array) - True positive rates. n binary classification case, a tpr numpy array under different
+              thresholds will be returned, otherwise in multiclass case, a list of tpr numpy arrays
               will be returned and each element represents one category.
             - **thresholds** (np.array) - Thresholds used for computing fpr and tpr.
 

mindspore/train/metrics/root_mean_square_surface_distance.py

@@ -49,7 +49,8 @@ class RootMeanSquareDistance(Metric):
 
     Args:
         distance_metric (string): Three measurement methods are supported:
-                "euclidean", "chessboard" or "taxicab". Default: ``"euclidean"`` .
+                ``"euclidean"`` (Euclidean Distance) ,  ``"chessboard"`` (Chessboard Distance, Chebyshev Distance)
+                or  ``"taxicab"`` (Taxicab Distance, Manhattan Distance). Default: ``"euclidean"`` .
         symmetric (bool):  Whether to calculate the symmetric average root mean square distance between
                 y_pred and y. If False, only calculates :math:`RmsSurDis(y\_pred, y)` surface distance,
                 otherwise, the mean of  distance from `y_pred` to `y` and from `y` to `y_pred`, i.e.
@@ -175,7 +176,7 @@ class RootMeanSquareDistance(Metric):
         if residual_mean_square_distance.shape == (0,):
             return np.inf
 
-        rms_surface_distance = (residual_mean_square_distance**2).mean()
+        rms_surface_distance = (residual_mean_square_distance ** 2).mean()
 
         if not self.symmetric:
             return rms_surface_distance
@@ -184,7 +185,7 @@ class RootMeanSquareDistance(Metric):
         if contrary_residual_mean_square_distance.shape == (0,):
             return np.inf
 
-        contrary_rms_surface_distance = (contrary_residual_mean_square_distance**2).mean()
+        contrary_rms_surface_distance = (contrary_residual_mean_square_distance ** 2).mean()
 
         rms_distance = np.sqrt(np.mean((rms_surface_distance, contrary_rms_surface_distance)))
         return rms_distance