mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0rc1__cp310-cp310-win_amd64.whl

mindspore/.commit_id

@@ -1 +1 @@
-__commit_id__ = ''[sha1]:241c405d,[branch]:(HEAD->master,origin/master,origin/HEAD)''
+__commit_id__ = ''[sha1]:7f763125,[branch]:(HEAD->r2.6,origin/r2.6)''

mindspore/__init__.py

@@ -22,7 +22,7 @@ from mindspore.common import *
 from mindspore.common import _tensor_docs
 del _tensor_docs
 from mindspore.mindrecord import *
-from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr, reshard
+from mindspore.ops import _op_impl, grad, value_and_grad, vjp, jvp, jacfwd, jacrev, vmap, get_grad, constexpr
 from mindspore.train import *
 from mindspore.log import *
 from mindspore.utils import *
@@ -35,14 +35,16 @@ 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, \
-    Layout, sync_pipeline_shared_parameters, parameter_broadcast, load_segmented_checkpoints, unified_safetensors
+    Layout, sync_pipeline_shared_parameters, parameter_broadcast, load_segmented_checkpoints, unified_safetensors, \
+    load_distributed_checkpoint, merge_sliced_parameter, restore_group_info_list, \
+    build_searched_strategy
+from mindspore.parallel.function import reshard
 from mindspore.rewrite import SymbolTree, ScopedValue, Node, NodeType
 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, \
     is_invalid_or_jit_forbidden_method
-from mindspore import _install_custom
 from mindspore import mint
-from mindspore.ops_generate import arg_dtype_cast, arg_handler
+from mindspore.ops._utils import arg_handler, arg_dtype_cast
 
 __all__ = ["run_check"]
 __all__.extend(__version__)

mindspore/_check_jit_forbidden_api.py

@@ -81,6 +81,9 @@ def get_obj_module_and_name_info(obj):
         return None
     if isinstance(obj, (types.FunctionType, types.MethodType)):
         return obj.__module__, obj.__qualname__, "method or function"
+    if isinstance(obj, types.BuiltinMethodType):
+        class_name_and_method_name = obj.__qualname__.split('.')
+        return class_name_and_method_name[0], obj.__qualname__, "method or function"
     return obj.__module__, obj.__name__, "class"
 
 

mindspore/_checkparam.py

@@ -27,7 +27,7 @@ import numpy as np
 from mindspore import context
 from mindspore import log as logger
 from mindspore.common import dtype as mstype
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 
 EQ = 1  # ==
 NE = 2  # !=
@@ -1252,7 +1252,7 @@ def check_symbolic_shape(dynamic_inputs, actual_inputs):
         for index, (dyn_input, net_input) in enumerate(zip(dyn_inputs, net_inputs)):
             if isinstance(dyn_input, (tuple, list)):
                 run_check(dyn_input, net_input)
-            elif hasattr(dyn_input, "symbolic_shape"):
+            elif hasattr(dyn_input, "symbolic_shape") and getattr(dyn_input, "symbolic_shape") is not None:
                 _check_symbol(dyn_input, net_input, index, symbolic_shape_data)
 
     run_check(dynamic_inputs, actual_inputs)
@@ -1371,7 +1371,7 @@ def args_type_check(*type_args, **type_kwargs):
     return type_check
 
 
-def check_hook_fn(hook_type, hook_fn):
+def check_hook_fn(hook_fn):
     """Check hook fn"""
     if not isinstance(hook_fn, (FunctionType, MethodType)):
         raise TypeError(f"When using 'hook_type(hook_fn)', the type of 'hook_fn' must be python "
@@ -1380,35 +1380,5 @@ def check_hook_fn(hook_type, hook_fn):
     if hook_fn.__code__.co_name == "staging_specialize":
         raise TypeError(f"Decorating hook function {hook_fn.__name__} with '@jit' is not supported.")
 
-    tensor_hook_func_args_num = 1
-    pre_hook_func_args_num = 2
-    forward_hook_and_backward_hook_func_args_num = 3
-    # Real args number, exclude class method self param
-    hook_fn_args_num = len(inspect.signature(hook_fn).parameters)
-
-    if hook_type == "register_hook" and hook_fn_args_num != tensor_hook_func_args_num:
-        raise TypeError(f"Tensor hook function {hook_fn.__name__} arg num should be {tensor_hook_func_args_num}, but "
-                        f"got {hook_fn_args_num}")
-
-    if hook_type == "register_forward_pre_hook" and hook_fn_args_num != pre_hook_func_args_num:
-        raise TypeError(f"forward_pre_hook function {hook_fn.__name__} args num should be {pre_hook_func_args_num}, "
-                        f"but got {hook_fn_args_num}")
-
-    if (hook_type == "register_forward_hook" and
-            hook_fn_args_num != forward_hook_and_backward_hook_func_args_num):
-        raise TypeError(f"forward_hook function {hook_fn.__name__} args num should be "
-                        f"{forward_hook_and_backward_hook_func_args_num}, but got {hook_fn_args_num}")
-
-    if hook_type == "register_backward_pre_hook" and hook_fn_args_num != pre_hook_func_args_num:
-        raise TypeError(f"backward_pre_hook function {hook_fn.__name__} args num should be {pre_hook_func_args_num},"
-                        f" but got {hook_fn_args_num}")
-
-    if (hook_type == "register_backward_hook" and
-            hook_fn_args_num != forward_hook_and_backward_hook_func_args_num):
-        raise TypeError(f"backward_hook function {hook_fn.__name__} args num should be "
-                        f"{forward_hook_and_backward_hook_func_args_num}, but got {hook_fn_args_num}")
-
-    return True
-
 
 _set_record = {}

mindspore/_deprecated/__init__.py

@@ -0,0 +1,17 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Store the deprecated api temporarily."""
+from __future__ import absolute_import
+from mindspore._deprecated.jit import jit

mindspore/_deprecated/jit.py

@@ -0,0 +1,198 @@
+# Copyright 2024 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""Store the deprecated api temporarily."""
+from __future__ import absolute_import
+
+import os
+import types
+import time
+from functools import wraps
+from mindspore import log as logger
+from mindspore.common.tensor import Tensor as PythonTensor
+from mindspore.common.api import _get_jit_hash, _process_dyn_args, _handle_func_args, _JitExecutor
+from mindspore.parallel._utils import _is_pynative_parallel
+from mindspore._c_expression.amp import get_curr_amp_strategy
+from mindspore.common._pijit_context import PIJitCaptureContext
+
+
+_PYNATIVE_PARALLEL_FUNC_NAME = "after_shard"
+
+
+def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=None, compile_once=False):
+    """
+    Create a callable MindSpore graph from a Python function.
+
+    This allows the MindSpore runtime to apply optimizations based on graph.
+
+    Note:
+        - If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
+          will not accept `**kwargs`.
+        - It is not supported to run a function with decoration @jit(mode=“PIJit”)
+          in static graph mode, in which case the decoration @jit(mode=“PIJit”) is considered invalid.
+        - Calls to functions with decorated @jit(mode=“PIJit”) inside functions
+          decorated with @jit(mode=“PIJit”) are not supported,
+          and the decoration @jit(mode=“PIJit”) is considered invalid.
+
+    Args:
+        fn (Function): The Python function that will be run as a graph. Default: ``None`` .
+        mode (str): The type of jit used, the value of mode should be ``PIJit`` or ``PSJit``. Default: ``PSJit`` .
+
+            - PSJit:
+              Parse python ast to build graph.
+            - PIJit:
+              Parse python bytecode to build graph at runtime.
+
+        input_signature (Union[Tuple, List, Dict, Tensor]): The Tensor which describes the input arguments. The
+            shape and dtype of the Tensor will be supplied to this function. If `input_signature` is specified, the
+            input parameters of `fn` cannot accept `**kwargs`, and the shape and dtype of actual inputs should keep the
+            same as `input_signature`. Otherwise, TypeError will be raised. There are two mode for `input_signature`:
+
+            - Full mode: Arguments is a Tuple, List or a Tensor, and they will be used as all compile inputs
+              for graph-compiling.
+            - Incremental mode: Argument is a Dict, and they will set to some of the graph inputs, which will be
+              substituted into the input at the corresponding position for graph-compiling.
+
+            Default: ``None`` .
+
+        hash_args (Union[Object, List or Tuple of Objects]): The local free variables used inside `fn`,
+            like functions or objects of class defined outside `fn`. Calling `fn` again with change of `hash_args`
+            will trigger recompilation. Default: ``None`` .
+        jit_config (JitConfig): Jit config for compile. Default: ``None`` .
+        compile_once(bool): ``True``: The function would be compiled once when it was created many times.
+            But it may be wrong if the free variables were changed. ``False`` : It would be recompiled when
+            it was created again.
+            Default: ``False`` .
+
+    Returns:
+        Function, if `fn` is not None, returns a callable function that will execute the compiled function; If `fn` is
+        None, returns a decorator and when this decorator invokes with a single `fn` argument, the callable function is
+        equal to the case when `fn` is not None.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> import mindspore._deprecated.jit as jit
+        ...
+        >>> x = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
+        >>> y = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
+        ...
+        >>> # create a callable MindSpore graph by calling decorator @jit
+        >>> def tensor_add(x, y):
+        ...     z = x + y
+        ...     return z
+        ...
+        >>> tensor_add_graph = jit(fn=tensor_add)
+        >>> out = tensor_add_graph(x, y)
+        ...
+        >>> # create a callable MindSpore graph through decorator @jit
+        >>> @jit
+        ... def tensor_add_with_dec(x, y):
+        ...     z = x + y
+        ...     return z
+        ...
+        >>> out = tensor_add_with_dec(x, y)
+        ...
+        >>> # create a callable MindSpore graph through decorator @jit with input_signature parameter
+        >>> @jit(input_signature=(Tensor(np.ones([1, 1, 3, 3]).astype(np.float32)),
+        ...                       Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))))
+        ... def tensor_add_with_sig(x, y):
+        ...     z = x + y
+        ...     return z
+        ...
+        >>> out = tensor_add_with_sig(x, y)
+        ...
+        >>> @jit(input_signature={"y": Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))})
+        ... def tensor_add_with_sig_1(x, y):
+        ...     z = x + y
+        ...     return z
+        ...
+        >>> out1 = tensor_add_with_sig_1(x, y)
+        ...
+        ... # Set hash_args as fn, otherwise cache of compiled closure_fn will not be reused.
+        ... # While fn differs during calling again, recompilation will be triggered.
+        >>> def func(x):
+        ...     return ops.exp(x)
+        ...
+        >>> def closure_fn(x, fn):
+        ...     @jit(hash_args=fn)
+        ...     def inner_fn(a):
+        ...         return fn(a)
+        ...     return inner_fn(x)
+        ...
+        >>> inputs = Tensor(np.ones([10, 10, 10]).astype(np.float32))
+        >>> for i in range(10):
+        ...     closure_fn(inputs, func)
+        ...
+        ... # Set compile_once = True, otherwise the train_step will be compiled again.
+        >>> def train(x):
+        ...     @jit(compile_once = True)
+        ...     def train_step(x):
+        ...         return ops.exp(x)
+        ...     for i in range(10):
+        ...         train_step(x)
+        ...
+        >>> inputs = Tensor(np.ones([10, 10, 10]).astype(np.float32))
+        >>> for i in range(10):
+        ...     train(inputs)
+    """
+
+    def wrap_mindspore(func):
+        if not isinstance(compile_once, bool):
+            logger.warning(f"The parameter `compile_once` of jit should be a bool, "
+                           f"but got {type(compile_once)}.")
+        if hash_args:
+            hash_obj = _get_jit_hash(hash_args)
+        elif compile_once:
+            hash_obj = 0
+        else:
+            hash_obj = int(time.time() * 1e9)
+
+        dyn_args = _process_dyn_args(func, input_signature)
+
+        @wraps(func)
+        def staging_specialize(*args, **kwargs):
+            if os.getenv("MS_JIT") == '0':
+                return func(*args, **kwargs)
+
+            args, kwargs = _handle_func_args(func, *args, **kwargs)
+
+            process_obj = None
+            if args and not isinstance(args[0], PythonTensor) and hasattr(args[0], func.__name__):
+                process_obj = args[0]
+            # only the function or cell instance wrapped by shard will fall into this branch
+            if _is_pynative_parallel() and func.__name__ == _PYNATIVE_PARALLEL_FUNC_NAME:
+                process_obj = hash_args
+            # Handle auto mixed precision strategy.
+            if not hasattr(func, "amp_strategy"):
+                if isinstance(func, types.MethodType):
+                    setattr(func.__func__, "amp_strategy", get_curr_amp_strategy())
+                else:
+                    setattr(func, "amp_strategy", get_curr_amp_strategy())
+            out = _JitExecutor(func, hash_obj, dyn_args, process_obj, jit_config)(*args, **kwargs)
+            return out
+
+        return staging_specialize
+
+    wrap_func = wrap_mindspore
+    if mode == "PIJit":
+        wrap_func = PIJitCaptureContext(jit_config, input_signature)
+
+    if fn is not None:
+        return wrap_func(fn)
+    return wrap_func

mindspore/_extends/builtin_operations.py

@@ -20,7 +20,7 @@ from mindspore.ops import composite as C
 from mindspore.common.tensor import Tensor
 import mindspore.common.dtype as mstype
 from mindspore.common.dtype import dtype_to_nptype, get_py_obj_dtype
-from mindspore._c_expression import Tensor as CTensor
+from mindspore._c_expression import TensorPy as CTensor
 
 
 def ScalarAdd(x, y):

mindspore/_extends/parse/__init__.py

@@ -27,10 +27,10 @@ from .parser import (Parser, create_instance, is_supported_create_instance_type,
                      is_class_type, check_obj_bool, python_isinstance, ms_isinstance, convert_to_ms_csrtensor,
                      convert_to_ms_cootensor, 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, check_attrs, generate_lambda_object,
-                     check_is_subclass, check_attr_is_property, get_method_info, can_constant_fold, is_ms_tensor_method)
+                     get_obj_defined_from_obj_type, is_from_third_party_library, get_const_abs, get_const_round,
+                     get_const_len, convert_to_namedtuple, check_attrs, generate_lambda_object,
+                     check_is_subclass, check_attr_is_property, get_method_info, can_constant_fold,
+                     convert_to_mutable)
 
 __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',
@@ -42,8 +42,7 @@ __all__ = ['Parser', 'create_instance', 'is_supported_create_instance_type', 'ge
            'get_ms_class_name', 'is_class_type', 'check_obj_bool', 'python_isinstance', 'ms_isinstance',
            'convert_to_ms_csrtensor', 'convert_to_ms_cootensor', '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_class_member_recursive', 'get_obj_defined_from_obj_type',
            'is_from_third_party_library', 'get_const_abs', 'get_const_round', 'get_const_len', 'get_method_info',
-           'is_adapter_tensor_class', 'is_adapter_parameter_class', 'is_ms_tensor_method',
            'convert_to_namedtuple', 'check_attrs', 'generate_lambda_object', 'check_is_subclass', 'check_attr_is_property',
-           'can_constant_fold']
+           'can_constant_fold', 'convert_to_mutable']

mindspore/_extends/parse/compile_config.py

@@ -159,6 +159,14 @@ Value Range:
 """
 AMP_ENABLE_ALL_FG = ''
 
+"""
+Name: DUMP_IR_META_DSL
+Function: Whether to dump IR for meta op.
+Value Range:
+    String. The name of the operator that needs to dump IR.
+"""
+DUMP_IR_META_DSL = ''
+
 """
 Name: DUMP_IR_CONFIG
 Function: Configuring the generation method of IR graphs.
@@ -316,6 +324,15 @@ Value Range:
 """
 PYNATIVE_JIT_GRAD_MODE = ''
 
+"""
+Name: PIJIT_SUBGRAPH_BREAK_OPTIMIZE
+Function: Whether to enable subgraph break optimization in PIJit.
+Value Range:
+    0: Disable subgraph break optimization in PIJit.
+    Default: Enable.
+"""
+PIJIT_SUBGRAPH_BREAK_OPTIMIZE = ''
+
 """
 Name: PUT_ALL_CNODE_INTO_ORDER_LIST
 Function: Whether to put all CNode into order list in back prop.
@@ -341,6 +358,7 @@ __all__ = [
     "BOOST_PARSE",
     "GREED_PARSE",
     "AMP_ENABLE_ALL_FG",
+    "DUMP_IR_META_DSL",
     "DUMP_IR_CONFIG",
     "TRAVERSE_SUBSTITUTIONS_MODE",
     "PRE_LIFT",
@@ -359,5 +377,6 @@ __all__ = [
     "GRAD_FOR_SCALAR",
     "DEBUG_LEVEL",
     "PYNATIVE_JIT_GRAD_MODE",
+    "PIJIT_SUBGRAPH_BREAK_OPTIMIZE",
     "PUT_ALL_CNODE_INTO_ORDER_LIST",
 ]

mindspore/_extends/parse/deprecated/deprecated_tensor_method.py

@@ -97,7 +97,7 @@ deprecated_tensor_method_map = {
     # 39 greater
 
     # 40 greater_equal
-
+    "greater_equal": "deprecated_tensor_greater_equal",
     # 41 gt
 
     # 42 half
@@ -136,7 +136,6 @@ deprecated_tensor_method_map = {
 
     # 59 logical_or
     "logical_or": "tensor_logical_or",
-
     # 60 long
 
     # 61 lt
@@ -287,6 +286,7 @@ deprecated_tensor_method_map = {
 
     # 133 bincount
     "bincount": "tensor_bincount",
+    "roll": "tensor_roll",
     # 134 diff
 
     # 135 double
@@ -338,16 +338,23 @@ deprecated_tensor_method_map = {
     "atan": "deprecated_tensor_atan",
     "arctan": "deprecated_tensor_arctan",
     "dot": "deprecated_tensor_dot",
+    "copy_": "deprecated_tensor_copy_",
 
     # 153
+    "logsumexp": "deprecated_tensor_logsumexp",
 
     # 154
 
     # 155
-
+    "isneginf": "deprecated_tensor_isneginf",
     # 156
 
     # 157
+    "logaddexp": "deprecated_tensor_logaddexp",
+
+    "logaddexp2": "deprecated_tensor_logaddexp2",
+
+    "xlogy": "tensor_xlogy",
 
     # 158
     "unsqueeze": "deprecated_tensor_unsqueeze",
@@ -359,8 +366,18 @@ deprecated_tensor_method_map = {
 
     # 161
     "fmod": "deprecated_tensor_fmod",
+    "bitwise_or": "deprecated_bitwise_or",
+    "bitwise_and": "deprecated_bitwise_and",
+    "bitwise_xor": "deprecated_bitwise_xor",
+    "baddbmm": "deprecated_baddbmm",
+
     # 162 log10
     "log10": "tensor_log10",
+    # 732
+    "take": "deprecated_tensor_take",
+
+    # 186
+    "addcdiv": "deprecated_tensor_addcdiv",
 
     # 501
     "addbmm": "deprecated_tensor_addbmm",
@@ -370,6 +387,8 @@ deprecated_tensor_method_map = {
     "addmm": "deprecated_tensor_addmm",
     # 790 addmv
     "addmv": "deprecated_tensor_addmv",
+    # 846
+    "count_nonzero": "deprecated_tensor_count_nonzero",
     # 1028
     "var": "deprecated_tensor_var",
 }

mindspore/_extends/parse/jit_fallback_modules/check_utils.py

@@ -0,0 +1,123 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2025 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+""" Used to detect third party modules. """
+
+import os
+import sys
+import types
+import inspect
+from mindspore import log as logger
+from .third_party_modules import third_party_modules_whitelist
+from ..resources import convert_object_map
+
+
+class ThirdPartyLibraryChecker:
+    """
+    Check if a module or function is from third-party libraries.
+
+    Rules for detecting third-party libraries:
+
+    1. Python built-in modules and python standard libraries are third-party libraries.
+
+    2. Modules in third_party_modules_whitelist are treated as third-party libraries.
+
+    3. Third-party libraries usually have 'site-packages' in their installation path.
+
+    4. Modules with module names provided by MS_JIT_IGNORE_MODULES are treated as third-party
+       libraries, but those provided by MS_JIT_MODULES are not.
+
+    """
+    def __init__(self):
+        self.python_builtin_dir = os.path.realpath(os.path.dirname(os.__file__))
+
+    @staticmethod
+    def get_jit_modules():
+        """Modules in jit_modules require jit."""
+        jit_modules = []
+        # Get jit modules from environment variable.
+        env_modules = os.getenv('MS_JIT_MODULES')
+        if env_modules is not None:
+            jit_modules = env_modules.split(',')
+        return jit_modules
+
+    @staticmethod
+    def get_jit_ignore_modules():
+        """Modules in jit_ignore_modules do not need jit."""
+        jit_ignore_modules = []
+        # Get jit ignore modules from environment variable.
+        env_modules = os.getenv('MS_JIT_IGNORE_MODULES')
+        if env_modules is not None:
+            jit_ignore_modules = env_modules.split(',')
+        # sys.builtin_module_names do not need jit.
+        jit_ignore_modules.extend(sys.builtin_module_names)
+        return jit_ignore_modules
+
+    @staticmethod
+    def in_convert_map(value):
+        """Check if value in convert_object_map."""
+        value_hashable = True
+        try:
+            hash(value)
+        except TypeError:
+            value_hashable = False
+        return value_hashable and value in convert_object_map
+
+    def is_third_party_module(self, module):
+        """Check if module is a third-party library."""
+        module_leftmost_name = module.__name__.split('.')[0]
+        if module_leftmost_name == "mindspore":
+            return False
+        # Modules in jit_ignore_modules are treated as third-party libraries.
+        jit_ignore_modules = self.get_jit_ignore_modules()
+        if module_leftmost_name in jit_ignore_modules:
+            logger.debug(f"Found third-party module '{module_leftmost_name}' in jit_ignore_modules.")
+            return True
+        # Modules in jit_modules require jit and they are considered to be in user workspace.
+        jit_modules = self.get_jit_modules()
+        if module_leftmost_name in jit_modules:
+            logger.debug(f"Found user-defined module '{module_leftmost_name}' in jit_modules.")
+            return False
+        # A modules without __file__ attribute is considered to be in user workspace.
+        if not hasattr(module, '__file__'):
+            return False
+        module_path = os.path.realpath(module.__file__)
+        split_path = module_path.split(os.path.sep)
+        under_site_packages = "site-packages" in split_path
+        # Python builtin modules are treated as third-party libraries.
+        if not under_site_packages and module_path.startswith(self.python_builtin_dir):
+            logger.debug(f"Found python builtin module '{module.__name__}', which is a third-party module.")
+            return True
+        # Third-party modules are under site-packages.
+        if under_site_packages and module_leftmost_name in third_party_modules_whitelist:
+            logger.debug(f"Found third-party module '{module.__name__}' in path '{module_path}'")
+            return True
+        return False
+
+    def is_from_third_party_module(self, value):
+        """Check if value is from a third-party library."""
+        if inspect.ismodule(value):
+            return self.is_third_party_module(value)
+        if (isinstance(value, types.FunctionType) and not hasattr(value, "__jit_function__")) or \
+            (isinstance(value, types.MethodType) and not hasattr(value.__func__, "__jit_function__")):
+            if self.in_convert_map(value):
+                return False
+            module = inspect.getmodule(value)
+            return module is not None and self.is_third_party_module(module)
+        return False
+
+
+third_party_checker = ThirdPartyLibraryChecker()