mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

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,7 +31,7 @@ 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
@@ -40,9 +40,11 @@ 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
 
@@ -59,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
@@ -110,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.
@@ -124,6 +127,13 @@ _unsupported_convert_data_type = (
 )
 
 _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):
@@ -244,11 +254,10 @@ def resolve_symbol(namespace, symbol):
                                           "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
@@ -357,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':
@@ -408,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()
@@ -536,11 +552,50 @@ 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 with jit_class."""
     if isinstance(cls, type):
@@ -683,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)
@@ -744,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):
@@ -752,17 +823,18 @@ 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)
         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.
@@ -781,15 +853,27 @@ def get_script_ids(script):
 
 
 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.
@@ -819,7 +903,7 @@ class Parser:
     @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.")
@@ -860,7 +944,7 @@ class Parser:
         """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_object_map.get(value)
+        return _convert_map().get(value)
 
     def parse(self):
         """Parse the function or method."""
@@ -1048,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
-                res = res + [start_lineno, start_colno, end_lineno, end_colno]
+                res = res + [start_lineno, start_colno, end_lineno, end_colno, expr_src]
             else:
-                res = res + [0, 0, 0, 0]
+                res = res + [0, 0, 0, 0, '']
         return res

mindspore/_extends/parse/resources.py

@@ -36,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
@@ -163,13 +162,7 @@ convert_object_map = {
     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,