mindspore 2.2.10__cp37-cp37m-manylinux1_x86_64.whl → 2.2.14__cp37-cp37m-manylinux1_x86_64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = '[sha1]:93fa4635,[branch]:(HEAD,origin/r2.2.10-1,r2.2.10-1)'
+__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/_akg/akg/composite/build_module.py

@@ -19,6 +19,7 @@ import os
 import json
 from collections.abc import Iterable
 import akg
+import math
 from akg import tvm
 from tvm.autotvm.env import AutotvmGlobalScope
 from akg.utils.util import parse_workspace_map
@@ -314,12 +315,12 @@ def merge_attrs(attrs_a, attrs_b):
     return attrs
 
 
-def read_repo_file(repo_file):
+def read_repo_file(repo_file, is_json_load=True):
     if not os.path.exists(repo_file):
         return {}
     with open(repo_file, 'r') as f:
-        repo = json.loads(f.read())
-    return repo
+        repo = f.read()
+    return json.loads(repo) if is_json_load else repo
 
 
 def _get_default_repository_file(process):
@@ -639,6 +640,7 @@ def _build_to_module_ascend(desc_s_in, desc_d_in, attr, use_repo=True):
         ConstructType.NORMAL: _normal_postprocess,
     }
     process = desc_d_in["process"]
+    kernel_name = desc_d_in['op']
     ascend_type = get_ascend_type(desc_d_in)
     ascend_type_to_section = {"Ascend910A": "1.6", "Ascend310P3": "1.7",
                               "Ascend910B1": "2.1", "Ascend910B2": "2.2", "Ascend910B3": "2.3", "Ascend910B4": "2.4"}
@@ -650,10 +652,14 @@ def _build_to_module_ascend(desc_s_in, desc_d_in, attr, use_repo=True):
             attr["is_tbe_codegen"] = True
             attr["pragma_modshift"] = True
     segment_tree, segment_infos = get_construct_args(desc_s_in, attr, post_funcs)
+
+    if desc_d_in.get("enable_cce_lib"):
+        attr["enable_cce_lib"] = True
+        return _build_to_module_ascend_lib(desc_s_in, kernel_name)
+
     poly = True
     res = _cpp_build(attr, process, poly, segment_tree, segment_infos)
     if attr.get("is_tbe_codegen"):
-        kernel_name = desc_d_in['op']
         stmt_json = akg.tvm.save_json(res[0], "0.8.0")
         args_json = []
         for buf in res[1]:
@@ -669,6 +675,90 @@ def _build_to_module_ascend(desc_s_in, desc_d_in, attr, use_repo=True):
         return kernel_name
     return res
 
+def _build_to_module_ascend_lib(desc_s_in, kernel_name):
+    def _get_all_shape(shapes):
+        shape_split = shapes.split(".")
+        shape_list = []
+        for shape in shape_split:
+            if "-" in shape:
+                tmp_shape = shape.split("-")[0]
+                for _ in range(shape.count("-") + 1):
+                    shape_list.append(tmp_shape)
+            else:
+                shape_list.append(shape)
+        return shape_list
+    
+    def _get_tiling_info(desc_s):
+        compute, shape, dtype = generate_trait(desc_s)
+        tiling_info = {}
+        if "MatMul" in compute:
+            trans_a = compute.split("_")[1]
+            trans_b = compute.split("_")[-1].split(".")[0]
+
+            shape_list = _get_all_shape(shape)
+            bias_flag = int(len(shape_list) > 3)
+            tensor_A = shape_list[0]
+            tensor_B = shape_list[1]
+
+            tensor_A_split = tensor_A.split("_")
+            if len(tensor_A_split) > 2:
+                batch_size = int(tensor_A.split("_")[0])
+            else:
+                batch_size = 1
+            if trans_a == "1":
+                M = int(tensor_A_split[-1])
+                K = int(tensor_A_split[-2])
+            else:
+                M = int(tensor_A_split[-2])
+                K = int(tensor_A_split[-1])
+
+            if trans_b == "1":
+                N = int(tensor_B.split("_")[-2])
+            else:
+                N = int(tensor_B.split("_")[-1])
+            tensor_A_type = str(dtype.split("-")[0])
+            tiling_info = {"batch_size":batch_size, "M": M, "N": N, "K": K, "trans_a": int(trans_a), "trans_b": int(trans_b),
+                           "tensor_A_type": tensor_A_type, "bias_flag": bias_flag, "op_type": "MatMul"}
+        elif "PagedAttention" in compute or "PagedAttentionMask" in compute:
+            shape_list = _get_all_shape(shape)
+            query = shape_list[0]
+            key_cache = shape_list[1]
+            table_shape = shape_list[3]
+
+            num_tokens = int(query.split("_")[0])
+            num_heads = int(query.split("_")[1])
+            embedding_size = int(query.split("_")[2])
+            num_blocks = int(key_cache.split("_")[0])
+            block_size = int(key_cache.split("_")[1])
+            kv_heads = int(key_cache.split("_")[2])
+
+            max_num_blocks_per_query = int(table_shape.split("_")[1])
+            tor = float(1.0 / math.sqrt(1.0 * embedding_size))
+
+            tiling_info = {"num_tokens": num_tokens, "num_heads": num_heads, "embedding_size": embedding_size, 
+                           "num_blocks": num_blocks, "block_size": block_size, "max_num_blocks_per_query": max_num_blocks_per_query,
+                           "tor": tor, "kv_heads": kv_heads, "op_type": "PagedAttention"}
+            if "PagedAttentionMask" in compute:
+                mask_shape = shape_list[5]
+                tiling_info["mask"] = list(map(int, mask_shape.split("_")))
+                tiling_info["op_type"] = "PagedAttentionMask"
+        elif "ReshapeAndCache" in compute:
+            shape_list = _get_all_shape(shape)
+            kv = shape_list[0]
+
+            num_tokens = int(kv.split("_")[0])
+            num_heads = int(kv.split("_")[1])
+            head_size = int(kv.split("_")[2])
+
+            tiling_info = {"num_tokens": num_tokens, "num_heads": num_heads, "head_size": head_size, 
+                           "op_type": "ReshapeAndCache"}
+        return tiling_info
+
+    func = tvm.get_global_func("build_cce_lib")
+    tiling_info = _get_tiling_info(json.loads(desc_s_in))
+    func(kernel_name, tiling_info, None)
+    return kernel_name
+
 def _set_backend(desc_d):
     desc_d_process = desc_d
     for i, op in enumerate(desc_d.get("op_desc")):
@@ -766,4 +856,4 @@ def get_tiling_space(kernel_desc, level=1, attr=None):
         spaces['c0_mod'] = ret.c0_tile_mod_table.asnumpy().tolist()
         if level >= 2:
             spaces['tuning_space'] = ret.tiling_candidate.asnumpy().tolist()
-    return spaces
+    return spaces

mindspore/_akg/akg/topi/cpp/impl.py

@@ -39,7 +39,7 @@ def _load_lib():
     lib_path = []
 
     pwd = os.path.dirname(os.path.realpath(__file__))
-    paths = [os.path.realpath(pwd + "/../../lib"), os.path.realpath(pwd + "/../../../../../mindspore/lib")]
+    paths = [os.path.realpath(pwd + "/../../lib"), os.path.realpath(pwd + "/../../../../mindspore_lite/lib"), os.path.realpath(pwd + "/../../../../../mindspore/lib")]
     tar_so = "libakg.so"
     for path in paths:
         found_lib = False

mindspore/_akg/akg/tvm/_ffi/base.py

@@ -56,7 +56,7 @@ def _load_lib():
     lib_path = []
 
     pwd = os.path.dirname(os.path.realpath(__file__))
-    paths = [os.path.realpath(pwd + "/../../lib"), os.path.realpath(pwd + "/../../../../../mindspore/lib")]
+    paths = [os.path.realpath(pwd + "/../../lib"), os.path.realpath(pwd + "/../../../../mindspore_lite/lib"), os.path.realpath(pwd + "/../../../../../mindspore/lib")]
     tar_so = "libakg.so"
     for path in paths:
         found_lib = False

mindspore/_akg/akg/utils/composite_op_helper.py

@@ -519,8 +519,13 @@ def _update_workspace_data(kernel_name, input_for_mod, output_indexes):
             kernel_desc = json.loads(kernel_json)
             if "workspace" in kernel_desc:
                 workspace_bytes = kernel_desc["workspace"]["size"]
-                item = np.full(workspace_bytes, np.nan, np.int8)
-                workspace_tensors.append(item)
+                workspace_num = kernel_desc["workspace"]["num"]
+                if len(workspace_bytes) != workspace_num:
+                    raise ValueError("workspace num %s and size shape %s are not equal!" 
+                                     % (len(workspace_bytes), workspace_num))
+                for i in range(kernel_desc["workspace"]["num"]):
+                    item = np.full(workspace_bytes[i], np.nan, np.int8)
+                    workspace_tensors.append(item)
     else:
         logging.warning("Kernel json file %s not found", json_file)
 

mindspore/_akg/akg/utils/dump_ascend_meta.py

@@ -24,9 +24,23 @@ import akg.tvm
 from akg.global_configs import get_kernel_meta_path
 from akg.utils.util import parse_workspace, write_code
 
+def set_ascend910b(code, core_type, title_dict):
+    if len(core_type) == 0:
+        return
+    if core_type == "MIX":
+        title_dict["magic"] = "RT_DEV_BINARY_MAGIC_ELF"
+        title_dict["coreType"] = "MIX"
+        title_dict["intercoreSync"] = 1
+        title_dict["taskRation"] = "1:2"
+    elif core_type == "AIC":
+        title_dict["coreType"] = "AiCore"
+        title_dict["magic"] = "RT_DEV_BINARY_MAGIC_ELF_AICUBE"
+    elif core_type == "AIV":
+        title_dict["coreType"] = "VectorCore"
+        title_dict["magic"] = "RT_DEV_BINARY_MAGIC_ELF_AIVEC"
 
 @akg.tvm.register_func
-def tvm_callback_cce_postproc(code, block_dim=1, workspace=None):
+def tvm_callback_cce_postproc(code, block_dim=1, workspace=None, core_type=""):
     """Function for dumping ascend meta."""
     if "__aicore__" in code:
         title_dict = {"magic": "RT_DEV_BINARY_MAGIC_ELF"}
@@ -35,8 +49,13 @@ def tvm_callback_cce_postproc(code, block_dim=1, workspace=None):
         title_dict = dict()
 
     # kernel name
-    kernel_name = code.split("_kernel")[0].split(" ")[-1]
-    title_dict["kernelName"] = kernel_name + "_kernel0"
+    if "_kernel" in code:
+        kernel_name = code.split("_kernel")[0].split(" ")[-1]
+        title_dict["kernelName"] = kernel_name + "_kernel0"
+    elif "_mix_aic" in code:
+        kernel_name = code.split("_mix_aic")[0].split(" ")[-1]
+        title_dict["kernelName"] = kernel_name
+    set_ascend910b(code, core_type, title_dict)
 
     # thread info
     title_dict["blockDim"] = block_dim

mindspore/_akg/akg/utils/util.py

@@ -29,6 +29,20 @@ def parse_int_const(value):
         return value.value
     return None
 
+def parse_workspace_array(workspace):
+    total_bytes = []
+    workspace_list = get_shape(workspace)
+    for ws in workspace_list:
+        total_bytes.append(parse_int_const(ws))
+
+    if total_bytes is None:
+        return None
+
+    workspace_dict = {
+        "num": len(total_bytes),
+        "size": total_bytes
+    }
+    return workspace_dict
 
 def parse_workspace_map(attrs):
     if not isinstance(attrs, akg.tvm.container.Map):
@@ -65,7 +79,10 @@ def parse_workspace(workspace):
 
     total_bytes = 0
     if "total_bytes" in workspace:
-        total_bytes = parse_int_const(workspace["total_bytes"])
+        ws = workspace["total_bytes"]
+        if isinstance(ws, akg.tvm.container.Array):
+            return parse_workspace_array(ws)
+        total_bytes = parse_int_const(ws)
 
     if total_bytes is None or total_bytes == 0:
         return None

mindspore/_extends/parse/__init__.py

@@ -28,7 +28,8 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      convert_class_to_function, convert_cell_list_to_sequence, is_cell_list, get_obj_from_sequence,
                      get_type, is_class_member_recursive, get_global_params, get_adapter_tensor_attr,
                      get_obj_defined_from_obj_type, is_from_third_party_library, get_const_abs, get_const_round,
-                     get_const_len, is_adapter_tensor_class, is_adapter_parameter_class, convert_to_namedtuple)
+                     get_const_len, is_adapter_tensor_class, is_adapter_parameter_class, convert_to_namedtuple,
+                     is_module_list)
 
 __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'generate_scope', 'get_attr_from_object',
            'get_bprop_method_of_class', 'get_class_instance_type', 'get_class_member_namespace_symbol',
@@ -41,4 +42,4 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            'convert_class_to_function', 'convert_cell_list_to_sequence', 'is_cell_list', 'get_obj_from_sequence',
            'get_type', 'is_class_member_recursive', 'get_adapter_tensor_attr', 'get_obj_defined_from_obj_type',
            'is_from_third_party_library', 'get_const_abs', 'get_const_round', 'get_const_len',
-           'is_adapter_tensor_class', 'is_adapter_parameter_class', 'convert_to_namedtuple',]
+           'is_adapter_tensor_class', 'is_adapter_parameter_class', 'convert_to_namedtuple', 'is_module_list']

mindspore/_extends/parse/parser.py

@@ -493,9 +493,14 @@ def is_cell_list(obj):
     return isinstance(obj, nn.CellList)
 
 
+def is_module_list(obj):
+    """Check if obj is nn.ModuleList"""
+    return hasattr(obj, "__cell_as_list__") and not isinstance(obj, nn.CellList)
+
+
 def convert_cell_list_to_sequence(obj):
     """Convert nn.CellList to sequence."""
-    if not isinstance(obj, nn.CellList):
+    if not hasattr(obj, "__cell_as_list__"):
         raise TypeError(f"Obj should be nn.CellList, but got {obj}")
     if not hasattr(obj, "_cells"):
         raise AttributeError(f"nn.CellList is missing _cells property.")

mindspore/_extends/parse/standard_method.py

@@ -2349,12 +2349,22 @@ def ms_iter(xs):
 
 def ms_next(it):
     """Implementation of `next`."""
-    return it.__ms_next__()
+    return it.__ms_next__
 
 
 def hasnext(it):
     """Implementation of `hasnext`."""
-    return it.__ms_hasnext__()
+    return it.__ms_hasnext__
+
+
+def str_next(xs):
+    """Next string."""
+    return xs[0], xs[1:]
+
+
+def str_hasnext(xs):
+    """Whether the string is empty or not."""
+    return len(xs) > 0
 
 
 @constexpr

mindspore/common/_utils.py

@@ -116,3 +116,19 @@ def load_lib(lib_path):
         logger.warning(f'Loading {lib_path} lib error.')
         return False
     return True
+
+
+def _jit_fallback_next_func(xs):
+    """Generate ms_next for xs"""
+    if hasattr(xs, "__next__"):
+        # Convert an iterator to tuple first.
+        xs = tuple(xs)
+    return xs[0], xs[1:]
+
+
+def _jit_fallback_has_next_func(xs):
+    """Determine whether xs has next value"""
+    if hasattr(xs, "__next__"):
+        # Convert an iterator to tuple first.
+        xs = tuple(xs)
+    return len(xs) > 0

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/cache_client.py

@@ -23,7 +23,7 @@ from ..core.validator_helpers import type_check, check_pos_int32, check_pos_uint
 
 
 class DatasetCache:
-    """
+    r"""
     A client to interface with tensor caching service.
 
     For details, please check `Tutorial <https://www.mindspore.cn/
@@ -46,7 +46,8 @@ class DatasetCache:
         >>>
         >>> # Create a cache instance with command line `cache_admin --start` and create a session with `cache_admin -g`
         >>> # After creating cache with a valid session, get session id with command `cache_admin --list_sessions`
-        >>> session_id = subprocess.getoutput('cache_admin --list_sessions | tail -1 | awk -F " " \'{{print $1;}}\'')
+        >>> command = "cache_admin --list_sessions | tail -1 | awk -F ' ' '{{print $1;}}'"
+        >>> session_id = subprocess.getoutput(command).split('\n')[-1]
         >>> some_cache = ds.DatasetCache(session_id=int(session_id), size=0)
         >>>
         >>> dataset_dir = "/path/to/image_folder_dataset_directory"
@@ -81,18 +82,20 @@ class DatasetCache:
         self.cache_client = CacheClient(session_id, size, spilling, hostname, port, num_connections, prefetch_size)
 
     def get_stat(self):
-        """
+        r"""
         Get the statistics from a cache. After data pipeline, three types of statistics can be obtained,
         including average number of cache hits (avg_cache_sz), number of caches in memory (num_mem_cached)
         and number of caches in disk (num_disk_cached).
 
         Examples:
             >>> import os
+            >>> import subprocess
             >>> import mindspore.dataset as ds
             >>>
             >>> # In example above, we created cache with a valid session id
-            >>> id = int(os.popen('cache_admin --list_sessions | tail -1 | awk -F " " \'{{print $1;}}\'').read())
-            >>> some_cache = ds.DatasetCache(session_id=id, size=0)
+            >>> command = "cache_admin --list_sessions | tail -1 | awk -F ' ' '{{print $1;}}'"
+            >>> id = subprocess.getoutput(command).split('\n')[-1]
+            >>> some_cache = ds.DatasetCache(session_id=int(id), size=0)
             >>>
             >>> # run the dataset pipeline to trigger cache
             >>> dataset = ds.ImageFolderDataset("/path/to/image_folder_dataset_directory", cache=some_cache)

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()