mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/experimental/optim/optimizer.py

@@ -0,0 +1,252 @@
+# Copyright 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.
+# 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.
+# ============================================================================
+"""optimizer"""
+from __future__ import absolute_import
+from collections import defaultdict
+from typing import Iterable
+from mindspore.ops import functional as F, composite as C, operations as P
+
+from mindspore.nn.cell import Cell
+from mindspore.common.parameter import Parameter, ParameterTuple
+from mindspore.common import Tensor
+import mindspore.common.dtype as mstype
+from mindspore import _checkparam as validator
+from mindspore import log as logger
+
+
+__all__ = ['Optimizer']
+
+
+class Optimizer(Cell):
+    r"""
+    Base class for all optimizers.
+
+    .. warning::
+        This is an experimental optimizer API that is subject to change.
+        This module must be used with lr scheduler module in `LRScheduler Class
+        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.experimental.html#lrscheduler-class>`_ .
+
+    Args:
+        params (Union[list(Parameter), list(dict)]): an iterable of :class:`mindspore.Parameter` or
+            dict. Specifies what Tensors should be optimized.
+        defaults (dict): a dict containing default values of optimization
+            options (used when a parameter group doesn't specify them).
+
+    Raises:
+        TypeError: If `learning_rate` is not one of int, float, Tensor.
+        TypeError: If element of `parameters` is neither Parameter nor dict.
+        TypeError: If `weight_decay` is neither float nor int.
+        ValueError: If `weight_decay` is less than 0.
+        ValueError: If `learning_rate` is a Tensor, but the dimension of tensor is greater than 1.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import nn, Tensor, Parameter
+        >>> from mindspore import ops
+        >>> from mindspore.experimental import optim
+        >>>
+        >>> class MySGD(optim.Optimizer):
+        ...    def __init__(self, params, lr):
+        ...        defaults = dict(lr=lr)
+        ...        super(MySGD, self).__init__(params, defaults)
+        ...
+        ...    def construct(self, gradients):
+        ...         for group_id, group in enumerate(self.param_groups):
+        ...            id = self.group_start_id[group_id]
+        ...            for i, param in enumerate(group["params"]):
+        ...                next_param = param + gradients[id+i] * group["lr"]
+        ...                ops.assign(param, next_param)
+        >>>
+        >>> net = nn.Dense(8, 2)
+        >>> data = Tensor(np.random.rand(20, 8).astype(np.float32))
+        >>> label = Tensor(np.random.rand(20, 2).astype(np.float32))
+        >>>
+        >>> optimizer = MySGD(net.trainable_params(), 0.01)
+        >>> optimizer.add_param_group({"params": Parameter([0.01, 0.02])})
+        >>>
+        >>> criterion = nn.MAELoss(reduction="mean")
+        >>>
+        >>> def forward_fn(data, label):
+        ...    logits = net(data)
+        ...    loss = criterion(logits, label)
+        ...    return loss, logits
+        >>>
+        >>> grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
+        >>>
+        >>> def train_step(data, label):
+        ...    (loss, _), grads = grad_fn(data, label)
+        ...    optimizer(grads)
+        ...    print(loss)
+        >>>
+        >>> train_step(data, label)
+    """
+    def __init__(self, params, defaults):
+        super(Optimizer, self).__init__(auto_prefix=False)
+
+        param_groups = self._parameters_base_check(params, "params")
+        self.defaults = defaults
+        self.state = defaultdict(dict)
+        self.param_groups = []
+        self.parameters = []
+        self.map_ = C.Map()
+        self.group_start_id = [0]
+        if not isinstance(param_groups[0], dict):
+            param_groups = [{'params': param_groups}]
+
+        for param_group in param_groups:
+            self.add_param_group(param_group)
+        self.parameters = ParameterTuple(self.parameters)
+        self.hyper_map = C.HyperMap()
+        self.enable_tuple_broaden = True
+
+    def __repr__(self):
+        format_string = self.__class__.__name__ + ' ('
+        for i, group in enumerate(self.param_groups):
+            format_string += '\n'
+            format_string += 'Parameter Group {0}\n'.format(i)
+            for key in sorted(group.keys()):
+                if key != 'params':
+                    format_string += '    {0}: {1}\n'.format(key, group[key].value()) \
+                        if key == "lr" and isinstance(group[key], Parameter) \
+                        else '    {0}: {1}\n'.format(key, group[key])
+        format_string += ')'
+        return format_string
+
+    def add_param_group(self, param_group):
+        r"""
+        Add a param group to the `Optimizer.param_groups`.
+
+        Args:
+            param_group (dict): Specifies what Parameters should be optimized along with group
+                specific optimization options.
+        """
+        group_id = len(self.param_groups)
+        param_group = self._preprocess_param_group(param_group)
+        self.parameters += tuple(param_group.get("params"))
+
+        for name, default in self.defaults.items():
+            if name not in param_group:
+                param_group.setdefault(name, default)
+
+        lr = self._build_single_lr(param_group.get("lr"), 'learning_rate_group_' + str(group_id))
+        weight_decay = self._preprocess_weight_decay(param_group.get("weight_decay", 0.0))
+        param_group["lr"] = lr
+        param_group["weight_decay"] = weight_decay
+        self.param_groups.append(param_group)
+        self.group_start_id.append(self.group_start_id[-1] + len(param_group.get("params")))
+
+    @staticmethod
+    def _parameters_base_check(parameters, param_info):
+        """Parameters base check."""
+        if parameters is None:
+            raise ValueError(f"For 'Optimizer', the argument {param_info} can not be None.")
+        if not isinstance(parameters, Iterable):
+            raise TypeError(f"For 'Optimizer', the argument {param_info} must be Iterable type, "
+                            f"but got {type(parameters)}.")
+        parameters = list(parameters)
+
+        if not parameters:
+            raise ValueError(f"For 'Optimizer', the argument {param_info} must not be empty.")
+        return parameters
+
+    def _decay_weight(self, weight_decay, params, gradients):
+        """Apply weight decay."""
+        if weight_decay != 0.:
+            weight_decay = Tensor(weight_decay, mstype.float32)
+            gradients = self.map_(F.partial(_apply_decay, weight_decay), params, gradients)
+        return gradients
+
+    def _preprocess_param_group(self, param_group):
+        """Preprocess param groups."""
+        if not isinstance(param_group, dict):
+            raise TypeError('Param group must be a dict.')
+
+        params = param_group['params']
+        if isinstance(params, Parameter):
+            param_group['params'] = [params]
+        elif isinstance(params, set):
+            raise TypeError('Optimizer parameters need to be organized in ordered collections, but '
+                            'the ordering of tensors in sets will change between runs. '
+                            'Please use a list instead.')
+        else:
+            param_group['params'] = list(params)
+
+        for param in param_group['params']:
+            if not isinstance(param, Parameter):
+                raise TypeError("Optimizer can only optimize Parameters, but one of the params is " + type(param))
+
+        if len(param_group['params']) != len(set(param_group['params'])):
+            logger.warning("Optimizer contains a parameter group with duplicate parameters.")
+
+        param_set = set()
+        for group in self.param_groups:
+            param_set.update(set(group['params']))
+        if not param_set.isdisjoint(set(param_group['params'])):
+            raise ValueError("some parameters appear in more than one parameter group.")
+        return param_group
+
+    def _build_single_lr(self, learning_rate, name):
+        """Check lr value, and convert lr to a float or a Tensor."""
+        if isinstance(learning_rate, (float, int)):
+            learning_rate = float(learning_rate)
+            validator.check_non_negative_float(learning_rate, "learning rate", self.cls_name)
+            return Parameter(Tensor(learning_rate, mstype.float32), name)
+
+        if isinstance(learning_rate, Tensor):
+            if learning_rate.ndim == 0:
+                return Parameter(learning_rate.astype(mstype.float32), name)
+            raise ValueError(f"For 'Optimizer', if 'learning_rate' is a Tensor, "
+                             f"then it should be scalar Tensor")
+
+        raise TypeError("For 'Optimizer', the argument 'learning_rate' must be int, float or Tensor, "
+                        "but got {}.".format(type(learning_rate)))
+
+    def _preprocess_weight_decay(self, weight_decay):
+        """preprocess weight decay"""
+        if isinstance(weight_decay, (float, int)):
+            weight_decay = float(weight_decay)
+            validator.check_non_negative_float(weight_decay, "weight_decay", self.cls_name)
+        else:
+            raise TypeError("For 'Optimizer', the argument 'Weight_decay' must be int or "
+                            "float.but got {}".format(type(weight_decay)))
+        return weight_decay
+
+    def construct(self, *hyper_params):
+        raise NotImplementedError
+
+op_add = P.AddN()
+op_gather = P.Gather()
+op_mul = P.Mul()
+
+_apply_decay = C.MultitypeFuncGraph("apply_decay")
+
+
+@_apply_decay.register("Tensor", "Tensor", "RowTensor")
+def _tensor_apply_decay_with_sparse(weight_decay, weight, gradient):
+    """Get grad with weight_decay."""
+    indices = gradient.indices
+    values = op_add((op_gather(weight, indices, 0) * F.cast(weight_decay, F.dtype(weight)), gradient.values))
+    shape = gradient.dense_shape
+    return RowTensorInner(indices, values, shape)
+
+
+@_apply_decay.register("Tensor", "Tensor", "Tensor")
+def _tensor_apply_decay(weight_decay, weight, gradient):
+    """Get grad with weight_decay."""
+    return op_add((op_mul(weight, F.cast(weight_decay, F.dtype(weight))), gradient))

mindspore/experimental/optim/sgd.py

@@ -0,0 +1,147 @@
+# Copyright 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.
+# 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.
+# ============================================================================
+"""sgd"""
+from __future__ import absolute_import
+
+from mindspore.ops import functional as F, composite as C, operations as P
+from mindspore.common.tensor import Tensor
+import mindspore.common.dtype as mstype
+from mindspore import _checkparam as Validator
+from mindspore.experimental.optim.optimizer import Optimizer
+
+_sgd_opt = C.MultitypeFuncGraph("sgd_opt")
+
+
+@_sgd_opt.register("Function", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor", "Tensor",)
+def _tensor_run_opt_ext(opt, momentum, learning_rate, gradient, weight, accum, stat):
+    """Apply sgd optimizer to the weight parameter using Tensor."""
+    success = True
+    success = F.depend(success, opt(weight, gradient, learning_rate, accum, momentum, stat))
+    return success
+
+
+class SGD(Optimizer):
+    r"""
+    Stochastic Gradient Descent optimizer.
+
+    .. math::
+        v_{t+1} = u \ast v_{t} + gradient \ast (1-dampening)
+
+    If nesterov is True:
+
+    .. math::
+        p_{t+1} = p_{t} - lr \ast (gradient + u \ast v_{t+1})
+
+    If nesterov is False:
+
+    .. math::
+        p_{t+1} = p_{t} - lr \ast v_{t+1}
+
+    To be noticed, for the first step, :math:`v_{t+1} = gradient`.
+
+    Here : where p, v and u denote the parameters, accum, and momentum respectively.
+
+    .. warning::
+        This is an experimental optimizer API that is subject to change.
+        This module must be used with lr scheduler module in `LRScheduler Class
+        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.experimental.html#lrscheduler-class>`_ .
+
+    Args:
+        params (Union[list(Parameter), list(dict)]): list of parameters to optimize or dicts defining
+            parameter groups.
+        lr (Union[int, float, Tensor]): learning rate.
+        momentum (Union[int, float], optional): momentum factor. Default: ``0``.
+        weight_decay (float, optional): weight decay (L2 penalty). Default: ``0``.
+        dampening (Union[int, float], optional): dampening for momentum. Default: ``0``.
+        nesterov (bool, optional): enables Nesterov momentum. Default: ``False``.
+
+    Keyword Args:
+        maximize (bool, optional): maximize the params based on the objective, instead of minimizing.
+            Default: ``False``.
+
+    Inputs:
+        - **gradients** (tuple[Tensor]) - The gradients of `params`.
+
+    Raises:
+        ValueError: If the learning rate is not int, float or Tensor.
+        ValueError: If the learning rate is less than 0.
+        ValueError: If the `momentum` or `weight_decay` value is less than 0.0.
+        ValueError: If the `momentum`, `dampening` or `weight_decay` value is not int or float.
+        ValueError: If the `nesterov` and `maximize` is not bool.
+        ValueError: If the `nesterov` is true, `momentum` is not positive or `dampening` is not 0.0.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import nn
+        >>> from mindspore.experimental import optim
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
+        >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
+        >>> optimizer = optim.SGD(net.trainable_params(), lr=0.1)
+        >>> def forward_fn(data, label):
+        ...     logits = net(data)
+        ...     loss = loss_fn(logits, label)
+        ...     return loss, logits
+        >>> grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
+        >>> def train_step(data, label):
+        ...     (loss, _), grads = grad_fn(data, label)
+        ...     optimizer(grads)
+        ...     return loss
+    """
+    def __init__(self, params, lr, momentum=0, dampening=0, weight_decay=0, nesterov=False, *,
+                 maximize=False):
+        Validator.check_value_type("lr", lr, [float, int, Tensor], self.cls_name)
+        if lr < 0.0:
+            raise ValueError("Invalid learning rate: {}".format(lr))
+        Validator.check_value_type("momentum", momentum, [int, float], self.cls_name)
+        if momentum < 0.0:
+            raise ValueError("Invalid momentum value: {}".format(momentum))
+        momentum = float(momentum)
+        Validator.check_value_type("nesterov", nesterov, [bool], self.cls_name)
+        Validator.check_value_type("maximize", maximize, [bool], self.cls_name)
+
+        defaults = dict(lr=lr, momentum=momentum, dampening=dampening,
+                        weight_decay=weight_decay, nesterov=nesterov,
+                        maximize=maximize, grad_centralization=False)
+        super(SGD, self).__init__(params, defaults)
+        for group in self.param_groups:
+            Validator.check_value_type("dampening", group.get("dampening"), [int, float], self.cls_name)
+            group["dampening"] = float(group.get("dampening"))
+        if nesterov and (momentum <= 0.0 or dampening != 0.0):
+            raise ValueError("For 'SGD', if 'nesterov' is true, 'momentum' must be > 0.0 and 'dampening' must "
+                             "equal to 0.0, but got 'momentum' {}, 'dampening' {}".format(momentum, dampening))
+        self.accum = self.parameters.clone(prefix="accum", init='zeros')
+        self.stat = self.parameters.clone(prefix="stat", init='ones')
+        self.op_cast = P.Cast()
+
+    def construct(self, gradients):
+        for group_id, group in enumerate(self.param_groups):
+            opt = P.SGD(group.get("dampening"), group.get("weight_decay"), group.get("nesterov"))
+            lr = group.get("lr")
+            if isinstance(lr, float):
+                lr = self.op_cast(group.get("lr"), mstype.float32)
+            maximize = group.get("maximize")
+            momentum = self.op_cast(group.get("momentum"), mstype.float32)
+            start_id = self.group_start_id[group_id]
+            end_id = self.group_start_id[group_id+1]
+            grads = gradients[start_id: end_id] if not maximize else -gradients[start_id: end_id]
+            self.hyper_map(F.partial(_sgd_opt, opt, momentum, lr), grads,
+                           self.parameters[start_id: end_id], self.accum[start_id: end_id],
+                           self.stat[start_id: end_id])
+        return True

mindspore/gen_ops.py

@@ -0,0 +1,273 @@
+# Copyright 2023-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.
+# ============================================================================
+"""
+Generate operator definition from ops.yaml
+"""
+import sys
+import os
+import yaml
+
+
+def generate_py_op_func(yaml_data, doc_data):
+    """
+    generate python operator function
+    """
+    gen_py = ''
+
+    op_desc_dict = {}
+    for operator_name, operator_desc in doc_data.items():
+        desc = operator_desc.get("description")
+        op_desc_dict[operator_name] = desc
+
+    for operator_name, operator_data in yaml_data.items():
+        description = op_desc_dict.get(operator_name)
+        args = operator_data.get('args')
+        func_name = operator_data.get('func_name')
+        if func_name is None:
+            func_name = operator_name
+
+        class_name = ''.join(word.capitalize() for word in operator_name.split('_'))
+        func_args = []
+        primitive_init_args = []
+        input_args = []
+        for arg_name, arg_info in args.items():
+            dtype = arg_info.get('dtype')
+            init_value = arg_info.get('init')
+            if init_value:
+                if dtype == 'str':
+                    init_value = '"' + init_value + '"'
+                func_args.append(f"""{arg_name}={init_value}""")
+                primitive_init_args.append(arg_name)
+            else:
+                func_args.append(arg_name)
+                input_args.append(arg_name)
+
+        function_code = f"""
+def {func_name}({', '.join(arg for arg in func_args)}):
+    \"\"\"
+    {description}
+    \"\"\"
+    {operator_name}_op = _get_cache_prim(P.{class_name})({', '.join(arg_name for arg_name in primitive_init_args)})
+    return {operator_name}_op({', '.join(arg_name for arg_name in input_args)})
+"""
+        gen_py += function_code
+
+    return gen_py
+
+
+def generate_py_primitive(yaml_data):
+    """
+    generate python primitive
+    """
+    gen_py = ''
+    for operator_name, operator_data in yaml_data.items():
+        args = operator_data.get('args')
+        func_name = operator_data.get('func_name')
+        if func_name is None:
+            func_name = operator_name
+
+        class_name = ''.join(word.capitalize() for word in operator_name.split('_'))
+
+        init_args_with_default = []
+        init_args = []
+        args_assign = []
+        for arg_name, arg_info in args.items():
+            dtype = arg_info.get('dtype')
+            type_cast = arg_info.get('type_cast')
+            type_cast_set = None
+            if type_cast:
+                type_cast_set = {ct.strip() for ct in type_cast.split(",")}
+
+            init_value = arg_info.get('init')
+            if init_value is None:
+                continue
+
+            if dtype == 'str':
+                init_value = '"' + init_value + '"'
+            init_args_with_default.append(f"""{arg_name}={init_value}""")
+            init_args.append(arg_name)
+
+            assign_str = f"""        self.{arg_name} = """
+
+            if type_cast_set:
+                assign_str += f'type_it({arg_name}, '
+                type_cast_list = []
+
+                if 'int' in type_cast_set:
+                    type_cast_list.append('INT')
+                if 'tuple[int]' in type_cast_list:
+                    type_cast_list.append('TUPLE')
+                #add more type cast kind here
+
+                assign_str += 'TypeCastKind.' + '_OR_'.join(ct for ct in type_cast_list)
+                if dtype == 'tuple[int]':
+                    assign_str += '_TO_TUPLE)'
+                if dtype == 'list[int]':
+                    assign_str += '_TO_LIST)'
+            else:
+                assign_str += arg_name
+            args_assign.append(assign_str)
+
+        args_assign = '\n'.join(assign for assign in args_assign)
+        primitive_code = f"""
+class {class_name}(Primitive):
+    def __init__(self, {', '.join(init_args_with_default)}):
+{args_assign}
+    def __call__(self, *args):
+        super.__call__(self, *args, {', '.join([f'self.{arg}' for arg in init_args])})
+"""
+
+        gen_py += primitive_code
+    return gen_py
+
+
+def generate_cc_opdef(yaml_data):
+    """
+    generate OpDef
+    """
+    gen_cc = ''
+    opdef_map_str = f"""
+std::unordered_map<std::string, OpDefPtr> gOpDefTable = {{"""
+
+    for operator_name, operator_data in yaml_data.items():
+        args = operator_data.get('args')
+        returns = operator_data.get('returns')
+        func_name = operator_data.get('func_name')
+        if func_name is None:
+            func_name = operator_name
+
+        class_name = ''.join(word.capitalize() for word in operator_name.split('_'))
+        opdef_map_str += f"""
+    {{"{operator_name}", &g{class_name}}},"""
+
+        opdef_cc = f"""
+OpDef g{class_name} = {{
+    .name_ = "{operator_name}","""
+        opdef_cc += f"""
+    .args_ = {{"""
+
+        for arg_name, arg_info in args.items():
+            dtype = arg_info.get('dtype')
+            init = arg_info.get('init')
+            if init is None:
+                init = 0
+            else:
+                init = 1
+            cc_dtype_str = 'DT_' + dtype.replace('[', '_').replace(']', '').replace('tuple', 'array').replace(
+                'list', 'array').upper()
+            cc_dtype_str.replace('TUPLE', 'ARRAY').replace('LIST', 'ARRAY')
+            opdef_cc += f"""
+                {{.arg_name_ = "{arg_name}", .arg_dtype_ = {cc_dtype_str}, .as_init_arg_ = {init}}},"""
+        opdef_cc += f"""
+    }},"""
+
+        opdef_cc += f"""
+    .returns_ = {{"""
+
+        for return_name, return_info in returns.items():
+            return_dtype = return_info.get('dtype')
+            cc_return_type_str = 'DT_' + return_dtype.replace('[', '_').replace(']', '').replace(
+                'tuple', 'array').replace('list', 'array').upper()
+            opdef_cc += f"""
+                {{.arg_name_ = "{return_name}", .arg_dtype_ = {cc_return_type_str}}},"""
+
+        opdef_cc += f"""
+    }},"""
+
+        opdef_cc += f"""
+}};"""
+        gen_cc += opdef_cc
+
+    opdef_map_str += f"""
+}};"""
+    gen_cc += opdef_map_str
+    return gen_cc
+
+
+if __name__ == "__main__":
+    work_path = ''
+    if len(sys.argv) > 1:
+        work_path = sys.argv[1]
+
+    yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops.yaml')
+    doc_yaml_path = os.path.join(work_path, 'mindspore/python/mindspore/ops_doc.yaml')
+    op_py_path = os.path.join(work_path, 'mindspore/python/mindspore/gen_ops_def.py')
+    op_cc_path = os.path.join(work_path, 'mindspore/core/ops/gen_ops_def.cc')
+
+    yaml_str = None
+    with open(yaml_path, 'r') as yaml_file:
+        yaml_str = yaml.safe_load(yaml_file)
+
+    doc_str = None
+    with open(doc_yaml_path, 'r') as doc_file:
+        doc_str = yaml.safe_load(doc_file)
+
+    cc_code = generate_cc_opdef(yaml_str)
+    cc_code += f"""
+}}  // namespace mindspore::ops"""
+
+    py_licence_str = f"""# Copyright 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.
+# 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.
+# ============================================================================
+"""
+    pyheader = f"""
+\"\"\"Operators definition generated by gen_os.py, includes functions and primitive classes.\"\"\"
+
+from mindspore.ops.primitive import Primitive
+from mindspore.ops import operations as P
+from mindspore.ops import functional as F
+from mindspore.ops._primitive_cache import _get_cache_prim
+from mindspore.ops.arg_dtype_cast import TypeCastKind, type_it
+"""
+    cc_license_str = f"""/**
+ * Copyright 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.
+ * 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.
+ */"""
+
+    ccheader = f"""
+#include "op_def.h"
+namespace mindspore::ops {{
+"""
+    py_prim = generate_py_primitive(yaml_str)
+    py_func = generate_py_op_func(yaml_str, doc_str)
+    py_file = None
+    with open(op_py_path, 'w') as py_file:
+        py_file.write(py_licence_str + pyheader + py_prim + py_func)
+
+    cc_file = None
+    with open(op_cc_path, 'w') as cc_file:
+        cc_file.write(cc_license_str + ccheader + cc_code)

mindspore/include/OWNERS

@@ -1,7 +1,6 @@
 approvers:
-- zhoufeng54
+- jpc_chenjianping #
 - zhang_xue_tong
-- jpc_chenjianping
 reviewers:
 - lx0095
 - xu-yfei