mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/_extends/parse/namespace.py

@@ -119,10 +119,17 @@ class ClassMemberNamespace(Namespace):
         except ValueError:
             raise UnboundLocalError(name)
         except KeyError:
-            # Check if cls is user-defined class decorated with ms_class. If true, an exception will be thrown.
+            # Check if cls is user-defined class decorated with jit_class. If true, an exception will be thrown.
             cls = d.__class__
             if hasattr(cls, '__ms_class__'):
                 raise NotImplementedError(f"'{cls.__name__ }' object has no attribute or method: '{name}'.")
+            # Class private attribute.
+            if name.startswith("__"):
+                private_member = "_" + cls.__name__ + name
+                if hasattr(d, private_member):
+                    logger.warning(f"The private attribute or method '{name}' is used in '{cls.__name__}'. " + \
+                                   f"In graph mode, '{name}' will be adjusted to '{private_member}' for parsing.")
+                    return getattr(d, private_member)
             logger.info(f"'{cls.__name__ }' object has no attribute or method: '{name}', so will return None.")
             raise AttributeError(name)
 
@@ -147,4 +154,12 @@ class ClassAttrNamespace(Namespace):
         except ValueError:
             raise UnboundLocalError(name)
         except KeyError:
-            raise AttributeError(f"'{d.__class__.__name__ }' object has no attribute or method: '{name}'.")
+            # Class private attribute.
+            cls = d.__class__
+            if name.startswith("__"):
+                private_attr = "_" + cls.__name__ + name
+                if hasattr(d, private_attr):
+                    logger.warning(f"The private attribute or method '{name}' is used in '{cls.__name__}'. " + \
+                                   f"In graph mode, '{name}' will be adjusted to '{private_attr}' for parsing.")
+                    return getattr(d, private_attr)
+            raise AttributeError(f"'{cls.__name__ }' object has no attribute or method: '{name}'.")

mindspore/_extends/parse/parser.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 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.
@@ -31,18 +31,22 @@ import numpy
 import asttokens
 import astunparse
 
-from mindspore import Tensor, CSRTensor, COOTensor
+from mindspore import Tensor, CSRTensor, COOTensor, RowTensor
 from mindspore import log as logger
 from mindspore import nn
 from mindspore import ops
 from mindspore import context
-from mindspore.common.api import _MindsporeFunctionExecutor, _convert_python_data
+from mindspore.common.api import _MindsporeFunctionExecutor
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
+from mindspore.common import mutable
+from mindspore.common._register_for_adapter import ms_adapter_registry
+from mindspore._checkparam import is_stub_tensor
 from .namespace import Namespace, CellNamespace, ClosureNamespace, ClassMemberNamespace, ClassAttrNamespace
 from .resources import parse_object_map, ops_symbol_map, convert_object_map, convert_class_to_function_map, trope_ns
-from .resources import SYMBOL_UNDEFINE, NO_IMPLEMENT
+from .resources import SYMBOL_UNDEFINE
 from .jit_fallback_modules import jit_fallback_third_party_modules_whitelist
+from ...common.api import _convert_python_data
 
 # Define return value
 RET_SUCCESS = 0
@@ -57,6 +61,7 @@ RESOLVE_TYPE_CLASS_INSTANCE = 4         # Resolve the class instance of common c
 RESOLVE_TYPE_NAMESPACE_INSTANCE = 5     # Resolve the namespace instance.
 RESOLVE_TYPE_NUMPY_INT_NUMBER = 6       # Resolve numpy int number.
 RESOLVE_TYPE_NUMPY_FLOAT_NUMBER = 7     # Resolve numpy float number.
+RESOLVE_TYPE_NUMPY_BOOL_NUMBER = 8     # Resolve numpy bool number.
 RESOLVE_TYPE_INVALID = 0xFF             # Resolve invalid.
 
 # Define the class instance detail type
@@ -93,7 +98,7 @@ SYNTAX_UNSUPPORTED_NAMESPACE = 4       # Unsupported namespace
 # Process expr statement white list
 # Add as needed, eg: "clear", "extend", "insert", "remove", "reverse"
 parse_expr_statement_white_list = (
-    "append", "insert", "clear", "reverse", "extend",
+    "append", "insert", "clear", "reverse", "extend", "update",
 )
 
 _builtin_function_or_method_type = type(abs)
@@ -108,7 +113,7 @@ _unsupported_internal_type = (
 )
 
 _hybrid_type = (
-    print, enumerate, zip, map, filter, abs, round, max, min, sum, hasattr, list, tuple
+    print, enumerate, zip, map, filter, abs, round, max, min, sum, getattr, hasattr, list, tuple
 )
 
 # Unsupported python builtin type in JIT Fallback.
@@ -117,6 +122,19 @@ _fallback_unsupported_python_builtin_type = (
     memoryview, property,
 )
 
+_unsupported_convert_data_type = (
+    mutable,
+)
+
+_global_params = {}
+_local_value_nodes = {}
+
+
+def _convert_map():
+    """Get convert object map"""
+    adapter_convert_map = ms_adapter_registry.convert_map
+    return adapter_convert_map if adapter_convert_map else convert_object_map
+
 
 def create_slice_obj(start, end, step):
     """Create slice object"""
@@ -233,14 +251,13 @@ def resolve_symbol(namespace, symbol):
             if namespace.name == "numpy" and \
                 isinstance(resolve_, (types.FunctionType, types.MethodType, types.ModuleType)):
                 raise NotImplementedError("Mindspore does not support to use the numpy methods " \
-                                          "within the construct() or @ms_function decorated function in graph mode.")
+                                          "within the construct() or @jit decorated function in graph mode.")
 
         # If need trope the obj
-        if resolve_ in convert_object_map:
-            resolve_ = convert_object_map.get(resolve_)
+        convert_map = _convert_map()
+        if resolve_ in convert_map:
+            resolve_ = convert_map.get(resolve_)
             logger.debug("Convert resolve: %r", resolve_)
-            if resolve_ == NO_IMPLEMENT:
-                raise NotImplementedError(f"Not support for '{symbol}'.")
     except Exception as e:
         if isinstance(e, NotImplementedError):
             raise e
@@ -310,6 +327,20 @@ def is_class_member(node):
     return False
 
 
+def is_class_member_recursive(node):
+    """Check the attr is class member variable resurcively."""
+    type_ = node.__class__.__name__
+    if type_ == "Attribute":
+        if hasattr(node.value, "value"):
+            return is_class_member_recursive(node.value)
+        if not hasattr(node.value, "id"):
+            return False
+        id_ = node.value.id
+        if id_ == "self":
+            return True
+    return False
+
+
 def get_obj_id(obj):
     """Get the obj id."""
     return str(id(obj))
@@ -335,6 +366,8 @@ def get_obj_type(obj):
         obj_type = RESOLVE_TYPE_NUMPY_INT_NUMBER
     elif _is_numpy_float_number(obj):
         obj_type = RESOLVE_TYPE_NUMPY_FLOAT_NUMBER
+    elif _is_numpy_bool_number(obj):
+        obj_type = RESOLVE_TYPE_NUMPY_BOOL_NUMBER
     else:
         # Raise a proper error if not using Fallback feature.
         if support_fallback_ != '0':
@@ -386,6 +419,11 @@ def _is_numpy_float_number(obj):
     return isinstance(obj, (numpy.float16, numpy.float32, numpy.float64))
 
 
+def _is_numpy_bool_number(obj):
+    """Confirm the obj is numpy bool number."""
+    return isinstance(obj, numpy.bool_)
+
+
 def _convert_tuple_to_args_kwargs(params):
     """Convert tuple to args and kwargs."""
     args = tuple()
@@ -514,13 +552,52 @@ def get_class_member_namespace_symbol(obj):
     return class_namespace
 
 
+def get_obj_defined_from_obj_type(obj_type):
+    """Get the class defined from object type which is in BuiltInMap."""
+    logger.debug("get the object type: %r", obj_type)
+
+    def func():
+        pass
+
+    obj_type_defined_map = {
+        "Tensor": Tensor,
+        "RowTensor": RowTensor,
+        "COOTensor": COOTensor,
+        "CSRTensor": CSRTensor,
+        "Parameter": Parameter,
+        "String": "",
+        "Function": func,
+        "Int": int,
+        "Float": float,
+        "UInt": int,
+        "Bool": bool,
+        "List": list,
+        "Tuple": tuple,
+        "Dictionary": dict,
+    }
+
+    return obj_type_defined_map.get(obj_type)
+
+
 def is_class_type(cls):
     """Check if cls is a class type."""
     return isinstance(cls, type)
 
 
+def get_adapter_tensor_attr(name):
+    """Get the method or @property modified function of the class, excluding those inherited from parent class."""
+    cls = ms_adapter_registry.tensor
+    properties = [key for key, value in vars(cls).items() if isinstance(value, property)]
+    if name in properties:
+        return getattr(cls, name).fget, True
+    methods = [key for key, value in vars(cls).items() if inspect.isfunction(value)]
+    if name in methods:
+        return getattr(cls, name), False
+    return None, False
+
+
 def get_ms_class_name(cls):
-    """Get the name of the class instance decorated by ms_class."""
+    """Get the name of the class instance decorated with jit_class."""
     if isinstance(cls, type):
         return cls.__name__
     return cls.__class__.__name__
@@ -661,29 +738,29 @@ def get_args_default_values(node):
             args=[arg(a), arg(b), arg(c)], vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[Num(1)]
         )
     """
-    nondefaults = [None] * (len(node.args.args) - len(node.args.defaults))
-    defaults = nondefaults + node.args.defaults + node.args.kw_defaults
+    defaults = [None] * (len(node.args.args) - len(node.args.defaults))
+    defaults = defaults + node.args.defaults
     if node.args.vararg:
         defaults.append(None)
+    defaults = defaults + node.args.kw_defaults
     if node.args.kwarg:
         defaults.append(None)
     return defaults
 
 
 def get_args(node):
-    """Get the arg of parse object."""
+    """Get the arg of parse object. The order is [args, vararg, kwonlyargs, kwarg]"""
     args = []
     # Process position args.
     for arg in node.args.args:
         args.append(arg)
-
-    # Process kwonlyargs: kwonlyargs is append after position args.
+    # Process vararg: vararg is append after position.
+    if node.args.vararg:
+        args.append(node.args.vararg)
+    # Process kwonlyargs: kwonlyargs is append after vararg.
     if node.args.kwonlyargs:
         for kwonlyarg in node.args.kwonlyargs:
             args.append(kwonlyarg)
-    # Process vararg: vararg is append after kwonlyargs.
-    if node.args.vararg:
-        args.append(node.args.vararg)
     # Process kwarg: kwarg is append after vararg.
     if node.args.kwarg:
         args.append(node.args.kwarg)
@@ -722,6 +799,22 @@ def is_third_party_module(value):
     return False
 
 
+def _convert_stub_tensor(data):
+    """Convert stub tensor output to tensor"""
+    if is_stub_tensor(data):
+        return data.stub_sync()
+    if isinstance(data, tuple):
+        return tuple(_convert_stub_tensor(x) for x in data)
+    if isinstance(data, list):
+        # Keep the list object not change.
+        for _, input_data in enumerate(data):
+            input_data = _convert_stub_tensor(input_data)
+        return data
+    if isinstance(data, dict):
+        return dict((_convert_stub_tensor(key), _convert_stub_tensor(value)) for key, value in data.items())
+    return data
+
+
 def eval_script(exp_str, params):
     """Evaluate a python expression."""
     if not isinstance(params, tuple):
@@ -730,22 +823,24 @@ def eval_script(exp_str, params):
         raise ValueError(f"eval_script(), params tuple length is wrong, params: {params}")
 
     # Eval function parses the expression argument and evaluates it as a python expression.
-    logger.debug(f"exp_str: '{exp_str}', params: '{params}'")
     global_params = params[0]
     local_params = params[1]
+    logger.debug(f"exp_str: '{exp_str}', params: '{params}'")
     try:
         local_params = _convert_python_data(local_params)
-        obj = eval(exp_str, global_params, local_params)
+        res = eval(exp_str, global_params, local_params)
+        res = _convert_stub_tensor(res)
+        logger.debug(f"eval res: '{res}'")
     except Exception as e:
         error_info = f"When eval '{exp_str}' by using JIT Fallback feature, an error occurred: " + str(e) + \
             ". You can try to turn off JIT Fallback feature by 'export MS_DEV_ENABLE_FALLBACK=0'."
-        logger.error(error_info)
+        logger.debug(error_info)
         raise e
 
     # Convert set to tuple.
-    if isinstance(obj, set):
-        return tuple(obj)
-    return obj
+    if isinstance(res, set):
+        return tuple(res)
+    return res
 
 
 def get_script_ids(script):
@@ -757,6 +852,28 @@ def get_script_ids(script):
     return set(ids)
 
 
+def merge_global_params(global_dict):
+    """Merge the global parameter."""
+    logger.debug(f'merge global_dict: {global_dict}')
+    _global_params.update(global_dict)
+
+
+def get_global_params():
+    """Get the global parameter."""
+    logger.debug(f'get global_dict: {_global_params}')
+    return _global_params
+
+
+def set_local_variable(name, value):
+    """Set the local variable with name and value."""
+    _local_value_nodes[name] = value
+
+
+def get_local_variable(name):
+    """Get the local variable according name."""
+    return _local_value_nodes.get(name)
+
+
 class Parser:
     """
     Parser python code to ast tree.
@@ -780,12 +897,13 @@ class Parser:
         # Used to resolve the function's nonlocals.
         self.closure_namespace = ClosureNamespace(self.fn)
         self.function_name = self.fn.__qualname__
+        self.lines = []
         self.col_offset = 0
 
     @staticmethod
     def is_unsupported_namespace(value):
         """To check if not supported for namespace"""
-        unsupported = isinstance(value, _builtin_function_or_method_type) and value not in convert_object_map
+        unsupported = isinstance(value, _builtin_function_or_method_type) and value not in _convert_map()
         logger.debug(f"'{value}' unsupported: {unsupported}.")
         if unsupported and value in _fallback_unsupported_python_builtin_type:
             raise TypeError(f"'{value}' is not supported both in JIT Fallback and graph mode.")
@@ -817,6 +935,16 @@ class Parser:
                 return True
         return False
 
+    @staticmethod
+    def is_unsupported_convert_data_type(value):
+        """Check whether the value don't support to be converted in C++."""
+        return value in _unsupported_convert_data_type
+
+    def get_convert_object_for_unsupported_type(self, value):
+        """Get the convert object for value which don't support to be converted in C++."""
+        if not self.is_unsupported_convert_data_type(value):
+            return value
+        return _convert_map().get(value)
 
     def parse(self):
         """Parse the function or method."""
@@ -826,7 +954,8 @@ class Parser:
             attr = 'source'
             try:
                 source = inspect.getsourcelines(self.fn)
-                if context.get_context('support_binary') and '/mindspore/' not in self.filename and \
+                if context.get_context('support_binary') and \
+                   '/mindspore/' not in self.filename and '\\mindspore\\' not in self.filename and \
                    (not hasattr(self.fn, attr) or getattr(self.fn, attr) != source):
                     if not os.access(self.filename, os.W_OK):
                         raise PermissionError(f"Don't have the write permission on the file {self.filename}.")
@@ -843,8 +972,8 @@ class Parser:
                         raise OSError(f"Mindspore can not compile temporary source code in terminal. "
                                       f"Please write source code to a python file and run the file.")
                     raise e
-            lines, self.line_offset = source
-            original_src = ''.join(lines)
+            self.lines, self.line_offset = source
+            original_src = ''.join(self.lines)
             hexstr = hashlib.sha256(original_src.encode()).hexdigest()
             ast_tokens_cache = Parser.ast_cache.get(hexstr)
             if not ast_tokens_cache:
@@ -945,6 +1074,35 @@ class Parser:
                              f"but got {subclass_instance}.")
         return super(target_father_class, subclass_instance)
 
+    def get_source_code(self, start_lineno, start_colno, end_lineno, end_colno):
+        """
+        Get the script source at the location.
+
+        Args:
+            start_lineno: The start line no.
+            start_colno: The start column no.
+            end_lineno: The end line no.
+            end_colno: The end column no.
+
+        Returns:
+            str, the source string.
+        """
+        if start_lineno == 0:
+            logger.critical('start_lineno should not be 0')
+
+        first_line = self.lines[start_lineno - 1]
+        if start_lineno == end_lineno:
+            src = first_line[self.col_offset + start_colno:self.col_offset + end_colno]
+            return src
+
+        src = first_line[self.col_offset + start_colno:]
+        while start_lineno < end_lineno - 1:
+            src += self.lines[start_lineno]
+            start_lineno += 1
+        last_line = self.lines[end_lineno - 1]
+        src += last_line[:self.col_offset + end_colno]
+        return src
+
     def get_location(self, node):
         """
         Get location of node start and end line no.
@@ -956,7 +1114,7 @@ class Parser:
         Returns:
             List, [fileName, linestart, colstart, lineend, colend].
         """
-        ret = [self.filename]
+        res = [self.filename]
         err_exit = 0
         if isinstance(node, (list, tuple)):
             node_size = len(node)
@@ -974,11 +1132,12 @@ class Parser:
                     hasattr(end_node, "last_token"):
                 start_lineno, start_colno = start_node.first_token.start
                 end_lineno, end_colno = end_node.last_token.end
+                expr_src = self.get_source_code(start_lineno, start_colno, end_lineno, end_colno)
                 start_lineno += self.line_offset - 1
                 start_colno += self.col_offset
                 end_lineno += self.line_offset - 1
                 end_colno += self.col_offset
-                ret = ret + [start_lineno, start_colno, end_lineno, end_colno]
+                res = res + [start_lineno, start_colno, end_lineno, end_colno, expr_src]
             else:
-                ret = ret + [0, 0, 0, 0]
-        return ret
+                res = res + [0, 0, 0, 0, '']
+        return res

mindspore/_extends/parse/resources.py

@@ -21,6 +21,8 @@ import ast
 import math
 
 from mindspore import RowTensor, SparseTensor, COOTensor, CSRTensor
+from mindspore.experimental import MapParameter
+from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops import functional as F, composite as C
 from mindspore.ops import Primitive
 from mindspore.ops.composite import multitype_ops
@@ -34,7 +36,6 @@ functional_ns = CellNamespace('mindspore.ops.functional')
 composite_ns = CellNamespace('mindspore.ops.composite')
 trope_ns = CellNamespace('mindspore._extends.parse.trope')
 
-NO_IMPLEMENT = None         # not implemented
 SYMBOL_UNDEFINE = 0xFF      # Undefined var and function
 
 # Some space set aside for readability of code
@@ -110,6 +111,7 @@ convert_object_map = {
     T.floordiv:     multitype_ops.floordiv,
     T.mod:          multitype_ops.mod,
     T.pow:          multitype_ops.pow_,
+    T.matmul:       F.matmul,
     T.lshift:       multitype_ops.left_shift,
     T.rshift:       multitype_ops.right_shift,
     T.and_:         multitype_ops.bitwise_and,
@@ -157,21 +159,18 @@ convert_object_map = {
     T.make_slice:   F.make_slice,
     T.range:        F.make_range,
     T.while_cond:   M.while_cond,
+    T.mutable:      Primitive('mutable'),
 
     # lib function
-    math.floor:     NO_IMPLEMENT,
-    math.trunc:     NO_IMPLEMENT,
-    math.exp:       NO_IMPLEMENT,
     math.log:       F.scalar_log,
-    math.sin:       NO_IMPLEMENT,
-    math.cos:       NO_IMPLEMENT,
-    math.tan:       NO_IMPLEMENT,
 
     # user defined
+    RowTensorInner: F.make_row_tensor_inner,
     RowTensor:      F.make_row_tensor,
     SparseTensor:   F.make_sparse_tensor,
     COOTensor:      F.make_coo_tensor,
-    CSRTensor:      F.make_csr_tensor
+    CSRTensor:      F.make_csr_tensor,
+    MapParameter:   F.make_map_parameter
 }
 
 if not security.enable_security():