mindspore 2.2.11__cp39-cp39-macosx_11_0_arm64.whl → 2.2.14__cp39-cp39-macosx_11_0_arm64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:8c390933,[branch]:(HEAD,origin/r2.2,r2.2)''
+__commit_id__ = ''[sha1]:4f30cd5f,[branch]:(HEAD,origin/r2.2,r2.2)''

mindspore/__init__.py

@@ -29,7 +29,8 @@ from mindspore.context import GRAPH_MODE, PYNATIVE_MODE, set_context, get_contex
 from mindspore.version import __version__
 from mindspore.profiler import Profiler, EnvProfiler
 from mindspore.parallel import set_algo_parameters, get_algo_parameters, reset_algo_parameters, \
-    rank_list_for_transform, transform_checkpoint_by_rank, transform_checkpoints, merge_pipeline_strategys, shard
+    rank_list_for_transform, transform_checkpoint_by_rank, transform_checkpoints, merge_pipeline_strategys, shard, \
+    load_segmented_checkpoints
 from mindspore.rewrite import SymbolTree, ScopedValue, Node, NodeType, TreeNodeHelper
 from mindspore.safeguard import obfuscate_ckpt, load_obf_params_into_net
 from mindspore._check_jit_forbidden_api import get_obj_module_and_name_info, is_jit_forbidden_module, \

mindspore/common/tensor.py

@@ -959,8 +959,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [11.  2.]
         """
         self._init_check()
-        if self.dtype == mstype.bfloat16:
-            raise TypeError(f"For asnumpy, the type of tensor cannot be BFloat16, but got {self.dtype}.")
         return Tensor_.asnumpy(self)
 
     def numpy(self):

mindspore/communication/management.py

@@ -74,6 +74,9 @@ def _check_parallel_envs():
     """
     if not GlobalComm.CHECK_ENVS:
         return
+    compile_level = os.getenv("MS_SIMULATION_LEVEL")
+    if compile_level:
+        return
     rank_id_str = os.getenv("RANK_ID")
     if not rank_id_str:
         raise RuntimeError("Environment variables RANK_ID has not been exported, please export variables 'RANK_ID'.")

mindspore/context.py

@@ -284,7 +284,8 @@ class _Context:
             'conv_allow_hf32': [True, False],
             'exception_dump': ["0", "1", "2"],
             'op_precision_mode': (str,),
-            'parallel_speed_up_json_path': (str, None)
+            'parallel_speed_up_json_path': (str, None),
+            'topo_order': (dict,)
         }
         ascend_cfg_setters = {
             'precision_mode': self._get_ascend_config_setter('precision_mode'),
@@ -294,7 +295,8 @@ class _Context:
             'conv_allow_hf32': self._get_ascend_config_setter('conv_allow_hf32', lambda v: "1" if v else "0"),
             'exception_dump': self._get_ascend_config_setter('exception_dump'),
             'op_precision_mode': self._set_op_precision_mode,
-            'parallel_speed_up_json_path': self._set_speedup_config_path
+            'parallel_speed_up_json_path': self._set_speedup_config_path,
+            'topo_order': self._set_topo_order
         }
         ascend_cfg_set = tuple(ascend_cfg_modes.keys())
         for ascend_key, ascend_value in ascend_config.items():
@@ -618,6 +620,28 @@ class _Context:
                              f"got '{op_precision_path}'.")
         self.set_param(ms_ctx_param.op_precision_mode, ascend_value)
 
+    def _set_topo_order(self, topo_order):
+        """
+        Set topo order.
+
+        Args:
+            topo_order (dict):
+                key: str, the name of the graph.
+                value: str, the topo order of the graph, should be one of 'dfs', 'bfs', 'rdfs'.
+        """
+        valid_order = {'dfs', 'bfs', 'rdfs'}
+        if not isinstance(topo_order, dict):
+            raise TypeError(f"For 'ascend_config', the 'topo_order' should be a dict, "
+                            f"got '{type(topo_order)}'.")
+        for k, v in topo_order.items():
+            if not isinstance(k, str):
+                raise TypeError("key {} is not a str".format(k))
+            if v not in valid_order:
+                raise ValueError("value {} should be one of {}.".format(v, valid_order))
+
+        options_str = json.dumps(topo_order)
+        self.set_param(ms_ctx_param.topo_order, options_str)
+
     def _set_speedup_config_path(self, speedup_config_path):
         """"Check and set speedup config for auto parallel."""
         if speedup_config_path is None or speedup_config_path == "":
@@ -681,7 +705,7 @@ def _context():
                  auto_parallel_search_mode=str, search_mode=str, parameter_broadcast=bool, strategy_ckpt_load_file=str,
                  strategy_ckpt_save_file=str, full_batch=bool, enable_parallel_optimizer=bool, enable_alltoall=bool,
                  all_reduce_fusion_config=list, pipeline_stages=int, pipeline_segments=int,
-                 parallel_optimizer_config=dict,
+                 pipeline_config=dict, parallel_optimizer_config=dict,
                  comm_fusion=dict, strategy_ckpt_config=dict)
 def set_auto_parallel_context(**kwargs):
     r"""
@@ -708,7 +732,7 @@ def set_auto_parallel_context(**kwargs):
     enable_parallel_optimizer    strategy_ckpt_save_file
     parallel_optimizer_config    dataset_strategy
     enable_alltoall              pipeline_stages
-               \                 auto_parallel_search_mode
+    pipeline_config              auto_parallel_search_mode
                \                 comm_fusion
                \                 strategy_ckpt_config
     ===========================  ===========================
@@ -777,6 +801,12 @@ def set_auto_parallel_context(**kwargs):
                         distributed alone in the pipeline. The total devices will be divided into 'pipeline_stags'
                         stages.
                         Default: ``1`` .
+        pipeline_config (dict): A dict contains the keys and values for setting the pipeline parallelism configuration.
+                        It supports the following keys:
+
+                        - pipeline_interleave(bool): Indicates whether to enable the interleaved execution mode.
+                        - pipeline_scheduler(str): Indicates the scheduling mode for pipeline parallelism. Only support
+                          ``gpipe/1f1b``.
         parallel_optimizer_config (dict): A dict contains the keys and values for setting the parallel optimizer
                         configure. The configure provides more detailed behavior control about parallel training
                         when parallel optimizer is enabled. The configure will be effective when we use

mindspore/dataset/engine/datasets.py

@@ -4051,6 +4051,15 @@ class ConcatDataset(UnionBaseDataset):
 
             self._sampler = sampler
             self._children_sizes = [c.get_dataset_size() for c in self.children]
+
+            # Recursive access to other child concat nodes
+            def set_child(node):
+                for c in node.children:
+                    if isinstance(c, ConcatDataset):
+                        c.use_sampler(sampler)
+                    set_child(c)
+            set_child(self)
+
             return
 
         if sampler.is_shuffled():
@@ -4186,6 +4195,12 @@ class _ToDevice:
         """
         return self._to_device.GetDataInfo()
 
+    def get_mbuf_queue_size(self):
+        """
+        Get element numbers inside mbuf.
+        """
+        return self._to_device.GetMbufQueueSize()
+
     def get_send_info(self):
         """
         In sink mode, it returns the send information of dataset at this moment.
@@ -4300,6 +4315,14 @@ class TransferDataset(Dataset):
             return self._to_device.get_data_info()
         raise RuntimeError("Calling get_data_info with bad state.")
 
+    def get_mbuf_queue_size(self):
+        """
+        Get element numbers inside mbuf.
+        """
+        if self._to_device is not None:
+            return self._to_device.get_mbuf_queue_size()
+        raise RuntimeError("Device queue is not init, call get_mbuf_queue_size failed.")
+
     def get_send_info(self):
         """
         In sink mode, it returns the send information of dataset at this moment.

mindspore/dataset/engine/validators.py

@@ -1021,7 +1021,7 @@ def check_minddataset(method):
         dataset_file = param_dict.get('dataset_files')
         if isinstance(dataset_file, list):
             if len(dataset_file) > 4096:
-                raise ValueError("length of dataset_file should be less than or equal to {}.".format(4096))
+                log.warning("The number of MindRecord files greater than 4096 may cause slow dataset initialization.")
             for f in dataset_file:
                 check_file(f)
         else:

mindspore/dataset/vision/py_transforms_util.py

@@ -1032,8 +1032,8 @@ def perspective(img, start_points, end_points, interpolation=Inter.BICUBIC):
         for pt1, pt2 in zip(transformed_points, original_points):
             matrix.append([pt1[0], pt1[1], 1, 0, 0, 0, -pt2[0] * pt1[0], -pt2[0] * pt1[1]])
             matrix.append([0, 0, 0, pt1[0], pt1[1], 1, -pt2[1] * pt1[0], -pt2[1] * pt1[1]])
-        matrix_a = np.array(matrix, dtype=np.float)
-        matrix_b = np.array(original_points, dtype=np.float).reshape(8)
+        matrix_a = np.array(matrix, dtype=float)
+        matrix_b = np.array(original_points, dtype=float).reshape(8)
         res = np.linalg.lstsq(matrix_a, matrix_b, rcond=None)[0]
         return res.tolist()
 

mindspore/experimental/optim/lr_scheduler.py

@@ -64,12 +64,11 @@ class LRScheduler:
         ...         super(ConstantLR, self).__init__(optimizer, last_epoch)
         ...
         ...     def get_lr(self):
-        ...         lrs = [lr.value() for lr in self._last_lr]
         ...         if self.last_epoch == 0:
-        ...             return [lr * self.factor for lr in lrs]
+        ...             return [lr * self.factor for lr in self._last_lr]
         ...         if self.last_epoch != self.total_iters:
-        ...             return lrs
-        ...         return sreturn [lr / self.factor for lr in lrs]
+        ...             return [lr * 1. for lr in self._last_lr]
+        ...         return [lr / self.factor for lr in self._last_lr]
         >>>
         >>> net = nn.Dense(8, 2)
         >>> optimizer = optim.SGD(net.trainable_params(), 0.01)
@@ -913,7 +912,7 @@ class ReduceLROnPlateau:
         >>> metrics = [1, 1.5, 1.8, 0.4, 0.5]
         >>> for i in range(5):
         ...     scheduler.step(metrics[i])
-        ...     current_lr = scheduler._last_lr
+        ...     current_lr = scheduler.get_last_lr()
         ...     print(current_lr)
         [Tensor(shape=[], dtype=Float32, value= 0.1)]
         [Tensor(shape=[], dtype=Float32, value= 0.01)]
@@ -1258,7 +1257,7 @@ class CosineAnnealingWarmRestarts(LRScheduler):
         >>> optimizer = optim.SGD(net.trainable_params(), lr=0.1, momentum=0.9)
         >>> scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, 2)
         >>> iters = 3
-        >>> for epoch in range(4):
+        >>> for epoch in range(2):
         ...     for i in range(iters):
         ...         scheduler.step(epoch + i / iters)
         ...         current_lr = scheduler.get_last_lr()

mindspore/mindrecord/tools/cifar100_to_mr.py

@@ -18,7 +18,6 @@ Cifar100 convert tool for MindRecord.
 
 from importlib import import_module
 import os
-import numpy as np
 
 from mindspore import log as logger
 from .cifar100 import Cifar100
@@ -26,10 +25,6 @@ from ..common.exceptions import PathNotExistsError
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread, SUCCESS, FAILED
 
-try:
-    cv_import = import_module("cv2")
-except ModuleNotFoundError:
-    cv_import = None
 
 __all__ = ['Cifar100ToMR']
 
@@ -57,6 +52,8 @@ class Cifar100ToMR:
     """
 
     def __init__(self, source, destination):
+        self.cv_import = import_module("cv2")
+
         check_filename(source)
         self.source = source
 
@@ -100,12 +97,12 @@ class Cifar100ToMR:
         test_coarse_labels = cifar100_data.Test.coarse_labels
         logger.info("test images coarse label: {}".format(coarse_labels.shape))
 
-        data_list = _construct_raw_data(images, fine_labels, coarse_labels)
-        test_data_list = _construct_raw_data(test_images, test_fine_labels, test_coarse_labels)
+        data_list = self._construct_raw_data(images, fine_labels, coarse_labels)
+        test_data_list = self._construct_raw_data(test_images, test_fine_labels, test_coarse_labels)
 
-        if _generate_mindrecord(self.destination, data_list, fields, "img_train") != SUCCESS:
+        if self._generate_mindrecord(self.destination, data_list, fields, "img_train") != SUCCESS:
             return FAILED
-        if _generate_mindrecord(self.destination + "_test", test_data_list, fields, "img_test") != SUCCESS:
+        if self._generate_mindrecord(self.destination + "_test", test_data_list, fields, "img_test") != SUCCESS:
             return FAILED
         return SUCCESS
 
@@ -142,57 +139,52 @@ class Cifar100ToMR:
             raise t.exception
         return t.res
 
+    def _construct_raw_data(self, images, fine_labels, coarse_labels):
+        """
+        Construct raw data from cifar100 data.
 
-def _construct_raw_data(images, fine_labels, coarse_labels):
-    """
-    Construct raw data from cifar100 data.
+        Args:
+            images (list): image list from cifar100.
+            fine_labels (list): fine label list from cifar100.
+            coarse_labels (list): coarse label list from cifar100.
 
-    Args:
-        images (list): image list from cifar100.
-        fine_labels (list): fine label list from cifar100.
-        coarse_labels (list): coarse label list from cifar100.
+        Returns:
+            list[dict], data dictionary constructed from cifar100.
+        """
+        raw_data = []
+        for i, img in enumerate(images):
+            fine_label = fine_labels[i][0]
+            coarse_label = coarse_labels[i][0]
+            _, img = self.cv_import.imencode(".jpeg", img[..., [2, 1, 0]])
+            row_data = {"id": int(i),
+                        "data": img.tobytes(),
+                        "fine_label": int(fine_label),
+                        "coarse_label": int(coarse_label)}
+            raw_data.append(row_data)
+        return raw_data
+
+    def _generate_mindrecord(self, file_name, raw_data, fields, schema_desc):
+        """
+        Generate MindRecord file from raw data.
 
-    Returns:
-        list[dict], data dictionary constructed from cifar100.
-    """
-    if not cv_import:
-        raise ModuleNotFoundError("opencv-python module not found, please use pip install it.")
-
-    raw_data = []
-    for i, img in enumerate(images):
-        fine_label = np.int(fine_labels[i][0])
-        coarse_label = np.int(coarse_labels[i][0])
-        _, img = cv_import.imencode(".jpeg", img[..., [2, 1, 0]])
-        row_data = {"id": int(i),
-                    "data": img.tobytes(),
-                    "fine_label": int(fine_label),
-                    "coarse_label": int(coarse_label)}
-        raw_data.append(row_data)
-    return raw_data
-
-
-def _generate_mindrecord(file_name, raw_data, fields, schema_desc):
-    """
-    Generate MindRecord file from raw data.
+        Args:
+            file_name (str): File name of MindRecord File.
+            fields (list[str]): Fields would be set as index which
+            could not belong to blob fields and type could not be 'array' or 'bytes'.
+            raw_data (dict): Dict of raw data.
+            schema_desc (str): String of schema description.
 
-    Args:
-        file_name (str): File name of MindRecord File.
-        fields (list[str]): Fields would be set as index which
-          could not belong to blob fields and type could not be 'array' or 'bytes'.
-        raw_data (dict): Dict of raw data.
-        schema_desc (str): String of schema description.
-
-    Returns:
-        MSRStatus, SUCCESS or FAILED.
-    """
-    schema = {"id": {"type": "int64"}, "fine_label": {"type": "int64"},
-              "coarse_label": {"type": "int64"}, "data": {"type": "bytes"}}
+        Returns:
+            MSRStatus, SUCCESS or FAILED.
+        """
+        schema = {"id": {"type": "int64"}, "fine_label": {"type": "int64"},
+                  "coarse_label": {"type": "int64"}, "data": {"type": "bytes"}}
 
-    logger.info("transformed MindRecord schema is: {}".format(schema))
+        logger.info("transformed MindRecord schema is: {}".format(schema))
 
-    writer = FileWriter(file_name, 1)
-    writer.add_schema(schema, schema_desc)
-    if fields and isinstance(fields, list):
-        writer.add_index(fields)
-    writer.write_raw_data(raw_data)
-    return writer.commit()
+        writer = FileWriter(file_name, 1)
+        writer.add_schema(schema, schema_desc)
+        if fields and isinstance(fields, list):
+            writer.add_index(fields)
+        writer.write_raw_data(raw_data)
+        return writer.commit()

mindspore/mindrecord/tools/cifar10_to_mr.py

@@ -18,7 +18,6 @@ Cifar10 convert tool for MindRecord.
 
 from importlib import import_module
 import os
-import numpy as np
 
 from mindspore import log as logger
 from .cifar10 import Cifar10
@@ -26,10 +25,6 @@ from ..common.exceptions import PathNotExistsError
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread, SUCCESS, FAILED
 
-try:
-    cv_import = import_module("cv2")
-except ModuleNotFoundError:
-    cv_import = None
 
 __all__ = ['Cifar10ToMR']
 
@@ -57,6 +52,8 @@ class Cifar10ToMR:
     """
 
     def __init__(self, source, destination):
+        self.cv_import = import_module("cv2")
+
         check_filename(source)
         self.source = source
 
@@ -96,12 +93,12 @@ class Cifar10ToMR:
         test_labels = cifar10_data.Test.labels
         logger.info("test images label: {}".format(test_labels.shape))
 
-        data_list = _construct_raw_data(images, labels)
-        test_data_list = _construct_raw_data(test_images, test_labels)
+        data_list = self._construct_raw_data(images, labels)
+        test_data_list = self._construct_raw_data(test_images, test_labels)
 
-        if _generate_mindrecord(self.destination, data_list, fields, "img_train") != SUCCESS:
+        if self._generate_mindrecord(self.destination, data_list, fields, "img_train") != SUCCESS:
             return FAILED
-        if _generate_mindrecord(self.destination + "_test", test_data_list, fields, "img_test") != SUCCESS:
+        if self._generate_mindrecord(self.destination + "_test", test_data_list, fields, "img_test") != SUCCESS:
             return FAILED
         return SUCCESS
 
@@ -137,56 +134,50 @@ class Cifar10ToMR:
             raise t.exception
         return t.res
 
+    def _construct_raw_data(self, images, labels):
+        """
+        Construct raw data from cifar10 data.
 
-def _construct_raw_data(images, labels):
-    """
-    Construct raw data from cifar10 data.
-
-    Args:
-        images (list): image list from cifar10.
-        labels (list): label list from cifar10.
-
-    Returns:
-        list[dict], data dictionary constructed from cifar10.
-    """
-
-    if not cv_import:
-        raise ModuleNotFoundError("opencv-python module not found, please use pip install it.")
-
-    raw_data = []
-    for i, img in enumerate(images):
-        label = np.int(labels[i][0])
-        _, img = cv_import.imencode(".jpeg", img[..., [2, 1, 0]])
-        row_data = {"id": int(i),
-                    "data": img.tobytes(),
-                    "label": int(label)}
-        raw_data.append(row_data)
-    return raw_data
+        Args:
+            images (list): image list from cifar10.
+            labels (list): label list from cifar10.
 
+        Returns:
+            list[dict], data dictionary constructed from cifar10.
+        """
+        raw_data = []
+        for i, img in enumerate(images):
+            label = labels[i][0]
+            _, img = self.cv_import.imencode(".jpeg", img[..., [2, 1, 0]])
+            row_data = {"id": int(i),
+                        "data": img.tobytes(),
+                        "label": int(label)}
+            raw_data.append(row_data)
+        return raw_data
+
+    def _generate_mindrecord(self, file_name, raw_data, fields, schema_desc):
+        """
+        Generate MindRecord file from raw data.
 
-def _generate_mindrecord(file_name, raw_data, fields, schema_desc):
-    """
-    Generate MindRecord file from raw data.
+        Args:
+            file_name (str): File name of MindRecord File.
+            fields (list[str]): Fields would be set as index which
+            could not belong to blob fields and type could not be 'array' or 'bytes'.
+            raw_data (dict): dict of raw data.
+            schema_desc (str): String of schema description.
 
-    Args:
-        file_name (str): File name of MindRecord File.
-        fields (list[str]): Fields would be set as index which
-          could not belong to blob fields and type could not be 'array' or 'bytes'.
-        raw_data (dict): dict of raw data.
-        schema_desc (str): String of schema description.
-
-    Returns:
-        MSRStatus, SUCCESS or FAILED.
-    """
+        Returns:
+            MSRStatus, SUCCESS or FAILED.
+        """
 
-    schema = {"id": {"type": "int64"}, "label": {"type": "int64"},
-              "data": {"type": "bytes"}}
+        schema = {"id": {"type": "int64"}, "label": {"type": "int64"},
+                  "data": {"type": "bytes"}}
 
-    logger.info("transformed MindRecord schema is: {}".format(schema))
+        logger.info("transformed MindRecord schema is: {}".format(schema))
 
-    writer = FileWriter(file_name, 1)
-    writer.add_schema(schema, schema_desc)
-    if fields and isinstance(fields, list):
-        writer.add_index(fields)
-    writer.write_raw_data(raw_data)
-    return writer.commit()
+        writer = FileWriter(file_name, 1)
+        writer.add_schema(schema, schema_desc)
+        if fields and isinstance(fields, list):
+            writer.add_index(fields)
+        writer.write_raw_data(raw_data)
+        return writer.commit()

mindspore/mindrecord/tools/csv_to_mr.py

@@ -22,10 +22,6 @@ from mindspore import log as logger
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread
 
-try:
-    pd = import_module("pandas")
-except ModuleNotFoundError:
-    pd = None
 
 __all__ = ['CsvToMR']
 
@@ -55,8 +51,7 @@ class CsvToMR:
     """
 
     def __init__(self, source, destination, columns_list=None, partition_number=1):
-        if not pd:
-            raise Exception("Module pandas is not found, please use pip install it.")
+        self.pd = import_module("pandas")
         if isinstance(source, str):
             check_filename(source)
             self.source = source
@@ -135,8 +130,8 @@ class CsvToMR:
         if not os.path.exists(self.source):
             raise IOError("Csv file {} do not exist.".format(self.source))
 
-        pd.set_option('display.max_columns', None)
-        df = pd.read_csv(self.source)
+        self.pd.set_option('display.max_columns', None)
+        df = self.pd.read_csv(self.source)
 
         csv_schema = self._get_schema(df)
 

mindspore/mindrecord/tools/mnist_to_mr.py

@@ -25,10 +25,6 @@ from mindspore import log as logger
 from ..filewriter import FileWriter
 from ..shardutils import check_filename, ExceptionThread, SUCCESS, FAILED
 
-try:
-    cv_import = import_module("cv2")
-except ModuleNotFoundError:
-    cv_import = None
 
 __all__ = ['MnistToMR']
 
@@ -58,6 +54,8 @@ class MnistToMR:
     """
 
     def __init__(self, source, destination, partition_number=1):
+        self.cv_import = import_module("cv2")
+
         self.image_size = 28
         self.num_channels = 1
 
@@ -89,9 +87,6 @@ class MnistToMR:
 
     # pylint: disable=missing-docstring
     def run(self):
-        if not cv_import:
-            raise ModuleNotFoundError("opencv-python module not found, please use pip install it.")
-
         if self._transform_train() == FAILED:
             return FAILED
         if self._transform_test() == FAILED:
@@ -155,7 +150,7 @@ class MnistToMR:
         train_data = self._extract_images(self.train_data_filename_)
         train_labels = self._extract_labels(self.train_labels_filename_)
         for data, label in zip(train_data, train_labels):
-            _, img = cv_import.imencode(".jpeg", data)
+            _, img = self.cv_import.imencode(".jpeg", data)
             yield {"label": int(label), "data": img.tobytes()}
 
     def _mnist_test_iterator(self):
@@ -168,7 +163,7 @@ class MnistToMR:
         test_data = self._extract_images(self.test_data_filename_)
         test_labels = self._extract_labels(self.test_labels_filename_)
         for data, label in zip(test_data, test_labels):
-            _, img = cv_import.imencode(".jpeg", data)
+            _, img = self.cv_import.imencode(".jpeg", data)
             yield {"label": int(label), "data": img.tobytes()}
 
     def _transform_train(self):

mindspore/mindrecord/tools/tfrecord_to_mr.py

@@ -97,10 +97,7 @@ class TFRecordToMR:
     """
 
     def __init__(self, source, destination, feature_dict, bytes_fields=None):
-        try:
-            self.tf = import_module("tensorflow")  # just used to convert tfrecord to mindrecord
-        except ModuleNotFoundError:
-            raise Exception("Module tensorflow is not found, please use pip install it.")
+        self.tf = import_module("tensorflow")  # just used to convert tfrecord to mindrecord
 
         if self.tf.__version__ < SupportedTensorFlowVersion:
             raise Exception("Module tensorflow version must be greater or equal {}.".format(SupportedTensorFlowVersion))

mindspore/nn/layer/activation.py

@@ -782,7 +782,7 @@ class Tanhshrink(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
+        >>> import mindspore as ms
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> x = Tensor(np.array([1, 2, 3, 2, 1]), ms.float16)

mindspore/nn/layer/embedding.py

@@ -522,12 +522,12 @@ class MultiFieldEmbeddingLookup(EmbeddingLookup):
           this interface. Type is Int32, Int64.
         - **input_values** (Tensor) - The shape of tensor is :math:`(batch\_size, seq\_length)`.
           Specifies the weights of elements of the input_indices. The lookout vector will multiply with
-          the input_values. Type is Float32.
+          the input_values. Type is float32.
         - **field_ids** (Tensor)  - The shape of tensor is :math:`(batch\_size, seq\_length)`.
           Specifies the field id of elements of the input_indices. Type is Int32.
 
     Outputs:
-        Tensor, the shape of tensor is :math:`(batch\_size, field\_size, embedding\_size)`. Type is Float32.
+        Tensor, the shape of tensor is :math:`(batch\_size, field\_size, embedding\_size)`. Type is float32.
 
     Raises:
         TypeError: If `vocab_size` or `embedding_size` or `field_size` is not an int.

mindspore/nn/loss/loss.py

@@ -1996,7 +1996,7 @@ class FocalLoss(LossBase):
         >>> import mindspore.nn as nn
         >>> logits = ms.Tensor([[0.8, 1.4], [0.5, 0.9], [1.2, 0.9]], ms.float32)
         >>> labels = ms.Tensor([[1], [1], [0]], ms.int32)
-        >>> focalloss = nn.FocalLoss(weight=Tensor([1, 2]), gamma=2.0, reduction='mean')
+        >>> focalloss = nn.FocalLoss(weight=ms.Tensor([1, 2]), gamma=2.0, reduction='mean')
         >>> output = focalloss(logits, labels)
         >>> print(output)
         0.12516622