mindspore 2.7.0rc1__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/experimental/llm_boost/register.py

@@ -1,130 +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.
-# ============================================================================
-"""LlmBoostRegister"""
-import inspect
-
-
-class LlmBoostType:
-    """Class module type for vision pretrain"""
-
-    def __init__(self):
-        pass
-
-    BUILDIN = 'BuildIn'
-    ASCEND_NATIVE = 'LLMBoost'
-
-
-class LlmBoostRegister:
-    """
-    Module class factory.
-    """
-
-    def __init__(self):
-        pass
-
-    registry = {}
-
-    @classmethod
-    def register(cls, boost_type=LlmBoostType.BUILDIN, alias=None):
-        """Register class into registry
-        Args:
-            boost_type:
-                boost type name, default LlmBoostType.BUILDIN
-            alias (str) : model_name
-
-        Returns:
-            wrapper
-        """
-
-        def wrapper(register_class):
-            """Register-Class with wrapper function.
-
-            Args:
-                register_class : class need to register
-
-            Returns:
-                wrapper of register_class
-            """
-            model_name = alias if alias is not None else register_class.__name__
-            if boost_type not in cls.registry:
-                cls.registry[boost_type] = {model_name: register_class}
-            else:
-                cls.registry[boost_type][model_name] = register_class
-            return register_class
-
-        return wrapper
-
-    @classmethod
-    def is_exist(cls, boost_type, model_name=None):
-        """Determine whether class name is in the current type group.
-
-        Args:
-            boost_type : Module type
-            model_name : model name
-
-        Returns:
-            True/False
-        """
-        if not model_name:
-            return boost_type in cls.registry
-        registered = boost_type in cls.registry and model_name in cls.registry.get(
-            boost_type)
-        return registered
-
-    @classmethod
-    def get_cls(cls, boost_type, model_name=None):
-        """Get class
-
-        Args:
-            boost_type : Module type
-            model_name : model name
-
-        Returns:
-            register_class
-        """
-        if not cls.is_exist(boost_type, model_name):
-            raise ValueError("Can't find class type {} class name {} \
-            in class registry".format(boost_type, model_name))
-
-        if not model_name:
-            raise ValueError(
-                "Can't find model. model name = {}".format(model_name))
-        register_class = cls.registry.get(boost_type).get(model_name)
-        return register_class
-
-    @classmethod
-    def get_instance(cls, boost_type=LlmBoostType.BUILDIN, model_name=None, **kwargs):
-        """Get instance.
-        Args:
-            boost_type : module type
-            model_name : model type
-        Returns:
-            object : The constructed object
-        """
-        if model_name is None:
-            raise ValueError("Class name cannot be None.")
-
-        if isinstance(model_name, str):
-            obj_cls = cls.get_cls(boost_type, model_name)
-        elif inspect.isclass(model_name):
-            obj_cls = model_name
-        else:
-            raise ValueError("Can't find boost type {} model name {} \
-            in class registry.".format(boost_type, model_name))
-
-        try:
-            return obj_cls(**kwargs)
-        except Exception as e:
-            raise type(e)('{}: {}'.format(obj_cls.__name__, e))

mindspore/experimental/llm_boost/utils.py

@@ -1,31 +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.
-# ============================================================================
-"""LlmBoostRegister"""
-import os
-from mindspore.communication import get_group_size, get_rank
-
-
-def get_real_rank():
-    try:
-        return get_rank()
-    except RuntimeError:
-        return int(os.getenv("RANK_ID", "0"))
-
-
-def get_real_group_size():
-    try:
-        return get_group_size()
-    except RuntimeError:
-        return int(os.getenv("RANK_SIZE", "1"))

mindspore/include/OWNERS

@@ -1,7 +0,0 @@
-approvers:
-- jpc_chenjianping #
-- zhang_xue_tong
-reviewers:
-- lx0095
-- xu-yfei
-- wilfchen

mindspore/nn/optim/_dist_optimizer_registry.py

@@ -1,111 +0,0 @@
-# Copyright 2022 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.
-# ============================================================================
-"""_dist_optimizer_registry"""
-from __future__ import absolute_import
-
-from inspect import isfunction
-
-from mindspore.parallel._ps_context import _get_ps_context, _is_ps_mode
-
-
-_create_func_map = {}
-
-
-def _register_dist_optimizer(optimizer_type, creating_func):
-    """
-    Register distributed optimizers.
-    This method should be called by original optimizers.
-    """
-    if optimizer_type in _create_func_map:
-        return
-    if not isfunction(creating_func):
-        raise TypeError("creating_func is not a function type!")
-    _create_func_map[optimizer_type] = creating_func
-
-
-def empty_creating_func(*args, **kwargs):
-    """Empty function as placeholder."""
-    return
-
-
-_pserver_optmizer_attrs = {
-    "ms_role": "MS_PSERVER",
-    "primitive_target": "CPU",
-    "update_parameter": True
-}
-
-
-def create_optimizers_on_pserver(optimizer_type, parameters, *args, **kwargs):
-    """
-    Create the optimizers on parameter server.
-    This method should be called only in Parameter Server training mode.
-    Return distributed optimizer list and the flag list which indicates whether the parameters use them.
-    The size of the two lists returned should be the same as the size of input 'parameters'
-    """
-    distributed_optimizer_list = []
-    use_flag_list = []
-    for index, param in enumerate(parameters):
-        if param.is_param_ps and (not param.cache_enable):
-            if optimizer_type not in _create_func_map:
-                raise ValueError("Optimizer type %s is not recognized!" % optimizer_type)
-            distributed_optimizer = _create_func_map.get(optimizer_type)(*args, **kwargs)
-
-            server_rank_id = index % _get_ps_context("server_num")
-            distributed_optimizer.add_prim_attr("rank_id", server_rank_id)
-            for key, value in _pserver_optmizer_attrs.items():
-                distributed_optimizer.add_prim_attr(key, value)
-            distributed_optimizer_list.append(distributed_optimizer)
-            use_flag_list.append(True)
-        else:
-            distributed_optimizer_list.append(empty_creating_func)
-            use_flag_list.append(False)
-    return distributed_optimizer_list, use_flag_list
-
-
-def no_distributed_optimizer(optimizer_type, parameters, *args, **kwargs):
-    """
-    In some cases, no distributed optimizers are needed.
-    But we still need to return lists so optimizer subclasses can build the network using HyperMap.
-    """
-    empty_list = []
-    use_flag_list = []
-    for _ in parameters:
-        empty_list.append(empty_creating_func)
-        use_flag_list.append(False)
-    return empty_list, use_flag_list
-
-
-def get_creating_func():
-    """
-    Returns creating functions for distributed optimizers.
-    """
-    # Only support optimizers in parameter server mode for now.
-    if _is_ps_mode():
-        return create_optimizers_on_pserver
-    return no_distributed_optimizer
-
-
-def generate_dist_optimizer_list(optimizer_type, parameters, *args, **kwargs):
-    """
-    Generate the distributed optimizers according to the execution mode.
-    Only Parameter Server training mode is supported for now.
-    """
-    func = get_creating_func()
-    opt_list, use_flag_list = func(optimizer_type, parameters, *args, **kwargs)
-    if len(opt_list) != len(parameters) or len(use_flag_list) != len(parameters):
-        raise ValueError(f"Size of distributed optimizer list should be the same as parameter list. "
-                         f"But got len(opt_list):{len(opt_list)}"
-                         f", len(parameters):{len(parameters)}")
-    return opt_list, tuple(use_flag_list)

mindspore/nn/reinforcement/_batch_read_write.py

@@ -1,142 +0,0 @@
-# Copyright 2022 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.
-# ============================================================================
-"""
-BatchReadWrite
-"""
-from __future__ import absolute_import
-
-from mindspore.nn.cell import Cell
-from mindspore.ops.operations._rl_inner_ops import BatchAssign
-
-
-class BatchWrite(Cell):
-    r"""BatchWrite: write a list of parameters to assign the target.
-
-    .. warning::
-        This is an experiential prototype that is subject to change and/or deletion.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import nn
-        >>> from mindspore.common.parameter import Parameter, ParameterTuple
-        >>> from mindspore.nn.reinforcement import BatchWrite
-        >>> class SourceNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(SourceNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.5, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1, weight_init=0)
-        >>> class DstNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(DstNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.1, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1)
-        >>> class Write(nn.Cell):
-        ...   def __init__(self, dst, src):
-        ...     super(Write, self).__init__()
-        ...     self.w = BatchWrite()
-        ...     self.dst = ParameterTuple(dst.trainable_params())
-        ...     self.src = ParameterTuple(src.trainable_params())
-        ...   def construct(self):
-        ...     success = self.w(self.dst, self.src)
-        ...     return success
-        >>> dst_net = DstNet()
-        >>> source_net = SourceNet()
-        >>> nets = nn.CellList()
-        >>> nets.append(dst_net)
-        >>> nets.append(source_net)
-        >>> success = Write(nets[0], nets[1])()
-    """
-    def __init__(self):
-        """Initialize BatchWrite"""
-        super(BatchWrite, self).__init__()
-        self.write = BatchAssign(lock=True)
-
-    def construct(self, dst, src):
-        """
-        Write the source parameter list to assign the dst.
-
-        Inputs:
-            - **dst** (tuple) - A paramameter tuple of the dst model.
-            - **src** (tuple) - A paramameter tuple of the source model.
-
-        Returns:
-            Bool, true.
-        """
-        self.write(dst, src)
-        return True
-
-
-class BatchRead(Cell):
-    r"""BatchRead: read a list of parameters to assign the target.
-
-    .. warning::
-        This is an experiential prototype that is subject to change and/or deletion.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import nn
-        >>> from mindspore.common.parameter import Parameter, ParameterTuple
-        >>> from mindspore.nn.reinforcement import BatchRead
-        >>> class SNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(SNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.5, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1, weight_init=0)
-        >>> class DNet(nn.Cell):
-        ...   def __init__(self):
-        ...     super(DNet, self).__init__()
-        ...     self.a = Parameter(Tensor(0.1, mstype.float32), name="a")
-        ...     self.dense = nn.Dense(in_channels=16, out_channels=1)
-        >>> class Read(nn.Cell):
-        ...   def __init__(self, dst, src):
-        ...     super(Read, self).__init__()
-        ...     self.read = BatchRead()
-        ...     self.dst = ParameterTuple(dst.trainable_params())
-        ...     self.src = ParameterTuple(src.trainable_params())
-        ...   def construct(self):
-        ...     success = self.read(self.dst, self.src)
-        ...     return success
-        >>> dst_net = DNet()
-        >>> source_net = SNet()
-        >>> nets = nn.CellList()
-        >>> nets.append(dst_net)
-        >>> nets.append(source_net)
-        >>> success = Read(nets[0], nets[1])()
-
-    """
-    def __init__(self):
-        """Initialize BatchRead"""
-        super(BatchRead, self).__init__()
-        self.read = BatchAssign(lock=False)
-
-    def construct(self, dst, src):
-        """
-        Read the source parameter list to assign the dst.
-
-        Inputs:
-            - **dst** (tuple) - A paramameter tuple of the dst model.
-            - **src** (tuple) - A paramameter tuple of the source model.
-
-        Returns:
-            Bool, true.
-        """
-        self.read(dst, src)
-        return True

mindspore/nn/reinforcement/_tensors_queue.py

@@ -1,152 +0,0 @@
-# Copyright 2022 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.
-# ============================================================================
-"""
-TensorsQueue, each element in the queue is a list of tensors.
-"""
-from __future__ import absolute_import
-
-from mindspore.nn.cell import Cell
-from mindspore.ops.operations import _rl_inner_ops as rl_ops
-from mindspore import _checkparam as Validator
-from mindspore.common import dtype as mstype
-
-
-class TensorsQueue(Cell):
-    r'''
-    TensorsQueue: a queue which stores tensors lists.
-
-    .. warning::
-        This is an experiential prototype that is subject to change and/or deletion.
-
-    Args:
-        dtype (mindspore.dtype): the data type in the TensorsQueue. Each tensor should have the same dtype.
-        shapes (tuple[int64]): the shape of each element in TensorsQueue.
-        size (int): the size of the TensorsQueue.
-        name (str): the name of this TensorsQueue. Default: "TQ".
-
-    Raises:
-        TypeError: If `dtype` is not mindspore number type.
-        ValueError: If `size` is less than 0.
-        ValueError: If `shapes` size is less than 1.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> from mindspore import Tensor
-        >>> import mindspore.nn as nn
-        >>> data1 = Tensor([[0, 1], [1, 2]], dtype=ms.float32)
-        >>> data2 = Tensor([1], dtype=ms.float32)
-        >>> tq = nn.TensorsQueue(dtype=ms.float32, shapes=((2, 2), (1,)), size=5)
-        >>> tq.put((data1, data2))
-        >>> ans = tq.pop()
-    '''
-
-    def __init__(self, dtype, shapes, size=0, name="TQ"):
-        """Initialize TensorsQueue"""
-        super(TensorsQueue, self).__init__()
-        Validator.check_subclass("dtype", dtype, mstype.number_type + (mstype.bool_,), self.cls_name)
-        Validator.check_int(size, 0, Validator.GE, "size", self.cls_name)
-        elements_num = len(shapes)
-        Validator.check_int(elements_num, 1, Validator.GE, "len(shapes)", self.cls_name)
-        self.handle_ = rl_ops.TensorsQueueCreate(dtype, shapes, size, name)()
-        self.tensors_q_put = rl_ops.TensorsQueuePut(dtype, shapes)
-        self.tensors_q_get = rl_ops.TensorsQueueGet(dtype, shapes)
-        self.tensors_q_pop = rl_ops.TensorsQueueGet(dtype, shapes, pop_after_get=True)
-        self.tensors_q_clear = rl_ops.TensorsQueueClear()
-        self.tensors_q_close = rl_ops.TensorsQueueClose()
-        self.tensors_q_size = rl_ops.TensorsQueueSize()
-        self.__is_tensors_queue__ = True
-
-    def put(self, element):
-        """
-        Put element(tuple(Tensors)) to TensorsQueue in the end of queue.
-
-        Args:
-            element (tuple(Tensor) or list[tensor]): The input element.
-
-        Returns:
-            Bool, true.
-        """
-        self.tensors_q_put(self.handle_, element)
-        return True
-
-    def get(self):
-        """
-        Get one element int the front of the TensorsQueue.
-
-        Returns:
-            tuple(Tensors), the element in TensorsQueue.
-        """
-        element = self.tensors_q_get(self.handle_)
-        return element
-
-    def pop(self):
-        """
-        Get one element int the front of the TensorsQueue, and remove it.
-
-        Returns:
-            tuple(Tensors), the element in TensorsQueue.
-        """
-        element = self.tensors_q_pop(self.handle_)
-        return element
-
-    def __graph_pop__(self):
-        """
-        Get one element int the front of the TensorsQueue, and remove it.
-        This is only used in graph mode.
-
-        Returns:
-            tuple(Tensors), the element in TensorsQueue.
-        """
-        element = self.tensors_q_pop(self.handle_)
-        return self.handle_, element
-
-    def size(self):
-        """
-        Get the used/available size of the TensorsQueue, and remove it.
-
-        Returns:
-            Tensor(mindspore.int64), the used size of TensorsQueue.
-        """
-        size = self.tensors_q_size(self.handle_)
-        return size
-
-    def close(self):
-        """
-        Close the created TensorsQueue.
-
-        .. warning::
-            Once close the TensorsQueue, every functions belong to this TensorsQueue will be disaviliable.
-            Every resources created in TensorsQueue will be removed. If this TensorsQueue will be used in next step
-            or somewhere, eg: next loop, please use `clear` instead.
-
-        Returns:
-            Bool, true.
-        """
-        self.tensors_q_close(self.handle_)
-        return True
-
-    def clear(self):
-        """
-        Clear the created TensorsQueue. Only reset the TensorsQueue, clear the data and reset the size
-        in TensorsQueue and keep the instance of this TensorsQueue.
-
-        Returns:
-            Bool, true.
-        """
-        self.tensors_q_clear(self.handle_)
-        return True