mindspore 2.6.0__cp310-cp310-win_amd64.whl → 2.7.0__cp310-cp310-win_amd64.whl

mindspore/_deprecated/jit.py

@@ -1,198 +0,0 @@
-# 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/remote/kernel_build_server_ascend.py

@@ -1,75 +0,0 @@
-# Copyright 2020-2021 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.
-# ============================================================================
-"""kernel build server for ascend"""
-import sys
-import warnings
-import json
-
-from mindspore._extends.parallel_compile.tbe_compiler.tbe_job_manager import TbeJobManager
-from mindspore._extends.remote.kernel_build_server import Messager, get_logger, AkgBuilder
-
-
-class AscendMessager(Messager):
-    """
-    Ascend Messager
-    It works as a server, communicating with c++ client.
-    """
-
-    def __init__(self, fdin, fdout):
-        super().__init__(fdin, fdout)
-        get_logger().info("[TRACE] Ascend Messager init...")
-        self.tbe_builder = TbeJobManager()
-        self.akg_builder = AkgBuilder("ASCEND")
-
-    def handle(self):
-        """
-        Communicate with remote client.
-        Reference protocol between them at PR#3821 and PR#3935
-        """
-        arg = self.get_message()
-        if arg.startswith('AKG'):
-            self.akg_builder.handle(self, arg)
-        else:
-            job_json = dict()
-            try:
-                job_json = json.loads(arg)
-            except json.decoder.JSONDecodeError:
-                get_logger().error("[TRACE] Request is not a json message: {}".format(arg))
-                self.send_ack(False)
-                self.exit()
-            finally:
-                pass
-
-            if "job_type" in job_json:
-                res = self.tbe_builder.job_handler(arg)
-                self.send_res(res)
-            else:
-                get_logger().error("[TRACE] Request is not a TBE Job message: {}".format(arg))
-                self.send_ack(False)
-                self.exit()
-
-    def exit(self):
-        self.tbe_builder.reset()
-        get_logger().info("[TRACE] Ascend Messager Exit...")
-        exit()
-
-
-if __name__ == '__main__':
-    warnings.simplefilter("ignore")
-    if len(sys.argv) != 3:
-        raise Exception('Incorrect argv: {}'.format(sys.argv))
-    get_logger().debug(f"[TRACE] argv: {str(sys.argv)}")
-    messager = AscendMessager(int(sys.argv[1]), int(sys.argv[2]))
-    messager.run()

mindspore/communication/_hccl_management.py

@@ -1,297 +0,0 @@
-# Copyright 2020 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.
-# ============================================================================
-"""HCCL management API"""
-from __future__ import absolute_import
-from __future__ import division
-
-import ctypes
-import os
-
-from mindspore import context
-from mindspore._c_expression import get_hccl_rank_id, get_hccl_rank_size
-
-MAX_GROUP_NAME_LEN = 127
-MAX_RANK_NUM = 4096
-HCCL_LIB = 'libhccl_plugin.so'
-HCCL_LIB_CTYPES = ""
-
-
-def check_group(group):
-    """
-    A function that check if a collection communication group is legal.
-
-    Returns:
-        None
-    """
-    if isinstance(group, (str)):
-        group_len = len(group)
-        if group_len > MAX_GROUP_NAME_LEN or group_len == 0:
-            raise ValueError("The length of communication group name must be in range [1, 127), "
-                             "but got the value : {} ".format(group_len))
-    else:
-        raise TypeError("The type of communication group name must be type of string, "
-                        "but got 'group' type : {}.".format(type(group)))
-
-
-def check_rank_num(rank_num):
-    """
-    A function that check if a collection communication rank number is legal.If not raise error.
-
-    Returns:
-        None
-    """
-    if isinstance(rank_num, (int)):
-        if rank_num > MAX_RANK_NUM or rank_num <= 0:
-            raise ValueError("For 'create_group', the size of argument 'rand_ids' should be greater than 0 and"
-                             "less than {}, but got the size of 'rank_ids' : {}.".format(MAX_RANK_NUM, rank_num))
-    else:
-        raise TypeError("The argument 'rank_num' must be type of int, "
-                        "but got 'rank_num' type : {}.".format(type(rank_num)))
-
-
-def check_rank_id(rank_id):
-    """
-    A function that check if a collection communication rank id is legal.If not raise error.
-
-    Returns:
-        None
-    """
-    if isinstance(rank_id, (int)):
-        if rank_id >= MAX_RANK_NUM or rank_id < 0:
-            raise ValueError("The rand id in the communication group must be greater or equal 0 and "
-                             "less than {}, but got type value : {}.".format(MAX_RANK_NUM, rank_id))
-    else:
-        raise TypeError("The rand id in the communication group must be must be type of int, "
-                        "but got type value : {}.".format(type(rank_id)))
-
-
-def load_lib():
-    """load hccl lib"""
-    try:
-        base_dir = os.path.dirname(os.path.realpath(__file__))
-        lib_path = os.path.join(base_dir, "../lib/plugin/ascend", HCCL_LIB)
-        hccl_lib = ctypes.CDLL(lib_path)
-    except Exception:
-        raise RuntimeError('Get hccl lib error.')
-
-    global HCCL_LIB_CTYPES
-    HCCL_LIB_CTYPES = hccl_lib
-
-
-def c_str(string):
-    """Convert a python string to C string."""
-    if not isinstance(string, str):
-        string = string.decode('ascii')
-    return ctypes.c_char_p(string.encode('utf-8'))
-
-
-def c_array(ctype, values):
-    """Create ctypes array from a python array."""
-    return (ctype * len(values))(*values)
-
-
-def create_group(group, rank_num, rank_ids):
-    """
-    Create group.
-
-    A function that creates a collection communication group which includes 'rank_num'
-    device and 'rank_ids' is the list of these ranks of devices.
-
-    Note:
-        The world group can not be created.
-
-    Returns:
-        None
-    """
-    check_group(group)
-    check_rank_num(rank_num)
-    if isinstance(rank_ids, (list)):
-        if rank_num != len(rank_ids):
-            raise ValueError("The argument 'rank_num' number should be equal to the length "
-                             "of rank_ids, but got 'rank_num' value : {} and 'rank_ids' value : {}."
-                             .format(rank_num, rank_ids))
-        for rank_id in rank_ids:
-            if not isinstance(rank_id, (int)) or rank_id < 0:
-                raise ValueError("The elements of argument 'rank_ids' must be "
-                                 "unsigned integer, but got the type : {}".format(type(rank_id)))
-        c_array_rank_ids = c_array(ctypes.c_uint, rank_ids)
-        c_rank_num = ctypes.c_uint(rank_num)
-        c_group = c_str(group)
-        ret = HCCL_LIB_CTYPES.HcomCreateGroup(c_group, c_rank_num, c_array_rank_ids)
-        if ret != 0:
-            raise RuntimeError('Create group error, the error code is {}.'.format(ret))
-    else:
-        raise TypeError("For 'create_group', the argument 'rank_ids' must be type of list, "
-                        "but got 'rank_ids' type : {}.".format(type(rank_ids)))
-
-
-def destroy_group(group):
-    """
-    A function that destroy the group which created by user.
-
-    Note:
-        The world group can not be destroy.
-
-    Returns:
-        None
-    """
-    check_group(group)
-    c_group = c_str(group)
-    ret = HCCL_LIB_CTYPES.HcomDestroyGroup(c_group)
-    if ret != 0:
-        raise RuntimeError('Destroy group error.')
-
-
-def get_rank_size(group="hccl_world_group"):
-    """
-    A function that returns the number of ranks within the given collection communication group.
-
-    Note:
-        The default group is hccl_world_group.
-
-    Returns:
-        An integer scalar with the num of ranks.
-    """
-
-    if context.get_context("mode") == context.PYNATIVE_MODE:
-        return get_hccl_rank_size()
-
-    check_group(group)
-    c_group = c_str(group)
-    c_rank_size = ctypes.c_uint()
-    ret = HCCL_LIB_CTYPES.HcomGetRankSize(c_group, ctypes.byref(c_rank_size))
-    if ret != 0:
-        raise RuntimeError('Get rank size error.')
-
-    return c_rank_size.value
-
-
-def get_rank_id(group="hccl_world_group"):
-    """
-    A function that returns the rank id of the calling process, within the given collection communication group.
-
-    Returns:
-        An integer scalar with the rank id of the calling process.
-    """
-
-    if context.get_context("mode") == context.PYNATIVE_MODE:
-        return get_hccl_rank_id()
-
-    check_group(group)
-    c_group = c_str(group)
-    c_rank_id = ctypes.c_uint()
-    ret = HCCL_LIB_CTYPES.HcomGetRankId(c_group, ctypes.byref(c_rank_id))
-    if ret != 0:
-        raise RuntimeError('Get rank id error.')
-
-    return c_rank_id.value
-
-
-
-def get_local_rank_size(group="hccl_world_group"):
-    """
-    A function that returns the number of local ranks within the given collection communication group.
-
-    Note:
-        The default group is hccl_world_group.
-
-    Returns:
-        An integer scalar with the num of local ranks.
-    """
-    if context.get_context("mode") is context.PYNATIVE_MODE:
-        raise RuntimeError("The function 'get_local_rank_size' is not supported in PYNATIVE_MODE, "
-                           "'get_local_rank_size' only support GRAPH_MODE")
-    check_group(group)
-    c_group = c_str(group)
-    c_local_rank_size = ctypes.c_uint()
-    ret = HCCL_LIB_CTYPES.HcomGetLocalRankSize(c_group, ctypes.byref(c_local_rank_size))
-    if ret != 0:
-        raise RuntimeError('Get local rank size error.')
-
-    return c_local_rank_size.value
-
-
-def get_local_rank_id(group="hccl_world_group"):
-    """
-    Get local rank id.
-
-    A function that returns the local rank id of the calling process, within the given collection communication group.
-
-    Returns:
-        An integer scalar with the local rank id of the calling process.
-    """
-
-    if context.get_context("mode") is context.PYNATIVE_MODE:
-        raise RuntimeError("The function 'get_local_rank_id' is not supported in PYNATIVE_MODE, "
-                           "'get_local_rank_id' only support GRAPH_MODE")
-    check_group(group)
-    c_group = c_str(group)
-    c_local_rank_id = ctypes.c_uint()
-    ret = HCCL_LIB_CTYPES.HcomGetLocalRankId(c_group, ctypes.byref(c_local_rank_id))
-    if ret != 0:
-        raise RuntimeError('Get local rank id error.')
-
-    return c_local_rank_id.value
-
-
-def get_world_rank_from_group_rank(group, group_rank_id):
-    """
-    Get world rank from group rank.
-
-    A function that returns the rank id in the world group corresponding to the
-    rank which id is 'group_rank_id' in the user group.
-
-    Returns:
-        An integer scalar with the rank id in the world group.
-    """
-    if context.get_context("mode") is context.PYNATIVE_MODE:
-        raise RuntimeError("The function 'get_world_rank_from_group_rank' is not supported in PYNATIVE_MODE, "
-                           "'get_world_rank_from_group_rank' only support GRAPH_MODE")
-    check_group(group)
-    check_rank_id(group_rank_id)
-    c_group = c_str(group)
-    c_group_rank_id = ctypes.c_uint(group_rank_id)
-    c_world_rank_id = ctypes.c_uint()
-    ret = HCCL_LIB_CTYPES.HcomGetWorldRankFromGroupRank(c_group, c_group_rank_id, ctypes.byref(c_world_rank_id))
-    if ret != 0:
-        raise RuntimeError('Get world rank from group rank error.')
-
-    return c_world_rank_id.value
-
-
-def get_group_rank_from_world_rank(world_rank_id, group):
-    """
-    Get group rank from world rank.
-
-    A function that returns the rank id in the user group corresponding to the
-    rank which id is 'world_rank_id' in the world group.
-
-    Returns:
-        An integer scalar with the rank id in the user group.
-    """
-    if context.get_context("mode") is context.PYNATIVE_MODE:
-        raise RuntimeError("The function 'get_group_rank_from_world_rank' is not supported in PYNATIVE_MODE, "
-                           "'get_group_rank_from_world_rank' only support GRAPH_MODE")
-    check_group(group)
-    check_rank_id(world_rank_id)
-    c_group = c_str(group)
-    c_world_rank_id = ctypes.c_uint(world_rank_id)
-    c_group_rank_id = ctypes.c_uint()
-    ret = HCCL_LIB_CTYPES.HcomGetGroupRankFromWorldRank(c_world_rank_id, c_group, ctypes.byref(c_group_rank_id))
-    if ret != 0:
-        raise RuntimeError('Get group rank from world rank error.')
-
-    return c_group_rank_id.value