mindspore 2.1.0__cp37-none-any.whl → 2.2.10__cp37-none-any.whl

mindspore/{nn/optim_ex → experimental/optim}/sgd.py

@@ -1,152 +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 operations as P
-from mindspore.common.tensor import Tensor
-import mindspore.common.dtype as mstype
-from mindspore import _checkparam as Validator
-from mindspore.nn.optim_ex.optimizer import Optimizer
-
-
-class SGD(Optimizer):
-    """
-    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.1/api_python/mindspore.nn.html#lrscheduler>`_ .
-
-    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
-        >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
-        >>> net = LeNet5()
-        >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-        >>> optimizer = nn.optim_ex.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["dampening"], [int, float], self.cls_name)
-            group["dampening"] = float(group["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):
-            params = []
-            grads = []
-            accums = []
-            stats = []
-            params, grads, accums, stats = self._init_group(group, gradients, params, grads,
-                                                            accums, stats, group_id)
-            opt = P.SGD(group["dampening"], group["weight_decay"], group["nesterov"])
-            lr = group["lr"]
-            if isinstance(lr, float):
-                lr = self.op_cast(group["lr"], mstype.float32)
-            momentum = self.op_cast(group["momentum"], mstype.float32)
-            self.apply_sgd(opt, params, grads, lr, accums, momentum, stats, group["maximize"],
-                           group["grad_centralization"])
-
-    def apply_sgd(self, opt, params, grads, lr, accums, momentum, stats, maximize, grad_centralization):
-        grads = self._gradients_centralization(grad_centralization, grads)
-
-        for i, param in enumerate(params):
-            grad = grads[i] if not maximize else -grads[i]
-            opt(param, grad, lr, accums[i], momentum, stats[i])
-
-    def _init_group(self, group, gradients, params, accums, grads, stats, group_id):
-        p_id = self.group_start_id[group_id]
-        for i, param in enumerate(group["params"]):
-            params.append(param)
-            grads.append(gradients[p_id+i])
-            accums.append(self.accum[p_id+i])
-            stats.append(self.stat[p_id+i])
-        return params, grads, accums, stats
+# 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,6 +1,5 @@
 approvers:
 - jpc_chenjianping #
-- zhoufeng54
 - zhang_xue_tong
 reviewers:
 - lx0095

mindspore/include/api/data_type.h

@@ -38,7 +38,8 @@ enum class DataType : int {
   kNumberTypeFloat16 = 42,
   kNumberTypeFloat32 = 43,
   kNumberTypeFloat64 = 44,
-  kNumberTypeEnd = 46,
+  kNumberTypeBFloat16 = 46,
+  kNumberTypeEnd = 53,
   // add new enum here
   kInvalidType = INT32_MAX,
 };

mindspore/include/api/graph.h

@@ -24,38 +24,23 @@
 #include "include/api/types.h"
 
 namespace mindspore {
-class NetData;
-class Net;
-
 class MS_API Graph {
  public:
   class GraphData;
-  enum Type : uint32_t {
-    kExpressionGraph = 0,  ///< graph as expression - can auto grad
-    kExecutableGraph = 1,  ///< graph is loaded as is
-    kUnknownTypeGraph = 0xffffffff
-  };
   Graph();
   explicit Graph(const std::shared_ptr<GraphData> &graph_data);
   explicit Graph(std::shared_ptr<GraphData> &&graph_data);
   explicit Graph(std::nullptr_t);
   ~Graph();
-  explicit Graph(Type executable);
-  explicit Graph(Net *net);
 
   enum ModelType ModelType() const;
   bool operator==(std::nullptr_t) const;
   bool operator!=(std::nullptr_t) const;
-  bool IsExecutable() { return graph_type_ == kExecutableGraph; }
 
  private:
   friend class GraphCell;
   friend class ModelImpl;
-  friend class NetImpl;
-  friend class Model;
   std::shared_ptr<GraphData> graph_data_;
-  std::shared_ptr<NetData> net_data_;
-  Type graph_type_ = kExecutableGraph;
 };
 }  // namespace mindspore
 #endif  // MINDSPORE_INCLUDE_API_GRAPH_H

mindspore/include/api/kernel.h

@@ -35,6 +35,8 @@ class MS_API Kernel : public IKernel<schema::Primitive> {
     Initialize();
   }
   virtual ~Kernel() = default;
+
+  int InferShape() override;
   /// \brief obtain kernel's type.
   ///
   /// \return kernel's type.