mindspore 2.7.0rc1__cp311-cp311-win_amd64.whl → 2.7.1__cp311-cp311-win_amd64.whl

mindspore/ops/operations/sparse_ops.py

@@ -2606,89 +2606,6 @@ class RaggedTensorToTensor(Primitive):
         self.add_prim_attr("num_row_partition_tensors", self.num_row_partition_tensors)
 
 
-class SparseCross(Primitive):
-    """
-    Generates sparse cross from a list of sparse and dense tensors.
-
-    Args:
-        hashed_output (bool): If true, returns the hash of the cross instead of the string. This will allow us
-                              avoiding string manipulations.
-        num_buckets (int): An int that is >= 0. It is used if "hashed_output" is true.output = hashed_value%num_buckets
-                           if num_buckets > 0 else "hashed_value".
-        hash_key (int): Specify the hash_key that will be used by the "FingerprintCat64" function to combine the
-                        crosses fingerprints.
-        out_type (mindspore.dtype): The output data type. Defaults to "int64".
-        internal_type (mindspore.dtype): An type int64.
-
-    Inputs:
-        - **indices** (list(Tensor)) - A list of Tensor objects with type int64. 2-D.
-          Indices of each input SparseTensor.
-        - **values** (list(Tensor)) - A list of Tensor objects with types from: int64.
-          1-D. values of each SparseTensor.
-        - **shapes** (list(Tensor)) - A list with the same length as indices of Tensor objects with type int64.
-          1-D. Shapes of each SparseTensor.
-        - **dense_inputs** (list(Tensor)) - A list of Tensor objects with types from: int64.
-          2-D. Columns represented by dense Tensor.
-
-    Outputs:
-        - **output_indices** (Tensor) - A Tensor of type int64. 2-D. Indices of the concatenated SparseTensor.
-        - **output_values** (Tensor) - A Tensor of type "out_type". 1-D.
-          Non-empty values of the concatenated or hashed SparseTensor.
-        - **output_shape** (Tensor) - A Tensor of type int64. 1-D. Shape of the concatenated SparseTensor.
-
-    Raises:
-        TypeError: The indices shape rank is not equal to the shape rank.
-        TypeError: The indices element number is not equal to the value element number.
-        TypeError: The indices shape rank should be 2.
-        TypeError: The denses shape rank should be 2.
-        TypeError: The shapes rank should be 2.
-
-    Supported Platforms:
-        ``CPU``
-
-    Examples:
-        >>> from mindspore.ops.operations.sparse_ops import SparseCross
-        >>> indice1 = Tensor([[0,0],[1,0],[1,1]], dtype=mstype.int64)
-        >>> value1 = Tensor([1, 2, 3], dtype=mstype.int64)
-        >>> shape1 = Tensor([2, 2], dtype=mstype.int64)
-        >>> dense1 = Tensor([[1],[2]], dtype=mstype.int64)
-        >>> indice2 = Tensor([[0,0],[1,0],[1,1]], dtype=mstype.int64)
-        >>> value2 = Tensor([1, 2, 3], dtype=mstype.int64)
-        >>> shape2 = Tensor([2, 2], dtype=mstype.int64)
-        >>> dense2 = Tensor([[1],[2]], dtype=mstype.int64)
-        >>> indices = [indice1, indice2]
-        >>> values = [value1, value2]
-        >>> shapes = [shape1, shape2]
-        >>> dense_inputs = [dense1, dense2]
-        >>> hashed_output=True
-        >>> hash_key= 2
-        >>> out_type= mstype.int64
-        >>> internal_type = mstype.int64
-        >>> num_buckets=0
-        >>> sparse_cross = SparseCross(hashed_output, hash_key, out_type, internal_type, num_buckets)
-        >>> out = sparse_cross(indices, values, shapes, dense_inputs)
-        >>> print(out)
-        (Tensor(shape=[5, 2], dtype=Int64, value=
-        [[0, 0],
-        [1, 0],
-        [1, 1],
-        [1, 2],
-        [1, 3]]), Tensor(shape=[5], dtype=Int64, value= [1350190460805457680, 6319552725219729347,
-        4652439303631496997, 7670687697825594049,  174086171018132662]), Tensor(shape=[2], dtype=Int64, value= [2, 4]))
-    """
-
-    @prim_attr_register
-    def __init__(self, hashed_output, hash_key, out_type, internal_type, num_buckets=0):
-        """Initialize SparseCross."""
-        self.init_prim_io_names(inputs=["indices", "values", "shapes", "dense_inputs"],
-                                outputs=["output_indices", "output_values", "output_shape"])
-        validator.check_value_type("hashed_output", hashed_output, [bool], self.name)
-        validator.check_value_type("hash_key", hash_key, [int], self.name)
-        validator.check_value_type("out_type", out_type, [mstype.Type], self.name)
-        validator.check_value_type("internal_type", internal_type, [mstype.Type], self.name)
-        validator.check_value_type("num_buckets", num_buckets, [int], self.name)
-
-
 class RaggedTensorToSparse(Primitive):
     r"""
     Converts a RaggedTensor into a SparseTensor with the same values.

mindspore/ops/primitive.py

@@ -20,7 +20,7 @@ import copy
 import numpy as np
 from mindspore.common.api import _wrap_func
 from mindspore.log import _LogActionOnce
-from mindspore import context, log as logger
+from mindspore import log as logger
 from mindspore.parallel._utils import _is_in_auto_parallel_mode, _is_in_data_parallel_mode, \
     _is_in_hybrid_parallel_mode, SUPPORTED_TUPLE_IN_TUPLE_STRATEGY
 from mindspore.parallel._ps_context import _is_ps_mode, _is_role_sched
@@ -214,22 +214,6 @@ class Primitive(Primitive_):
         if in_strategy is None and out_strategy is not None:
             raise ValueError(f'The out_strategy of {self.name} is {out_strategy}, need to set in_strategy,'
                              f' but got none')
-        if not _is_in_auto_parallel_mode():
-            mode = context.get_auto_parallel_context("parallel_mode")
-            if in_strategy is not None:
-                logger.warning(f"The in_strategy/in_layout of the operator in your network "
-                               f"will not take effect in {mode} mode. "
-                               f"This means the the shard function called in the network is ignored. \n"
-                               f"If you want to enable it, please use semi auto or auto parallel mode by "
-                               f"context.set_auto_parallel_context(parallel_mode=ParallelMode.SEMI_AUTO_PARALLEL "
-                               f"or context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)")
-            if out_strategy is not None:
-                logger.warning(f"The out_strategy/out_layout of the operator in your network "
-                               f"will not take effect in {mode} mode."
-                               f" This means the the shard function called in the network is ignored. \n"
-                               f"If you want to enable it, please use semi auto or auto parallel mode by "
-                               f"context.set_auto_parallel_context(parallel_mode=ParallelMode.SEMI_AUTO_PARALLEL "
-                               f"or context.set_auto_parallel_context(parallel_mode=ParallelMode.AUTO_PARALLEL)")
 
     def del_prim_attr(self, name):
         """
@@ -458,7 +442,7 @@ class Primitive(Primitive_):
 
             - If the computation involves something like randomization or global variable, the equivalence
               is not guaranteed currently.
-            - Not supported in pynative mode
+            - Should only be used in Graph mode or in gradient functions that are decorated by @jit.
 
         Args:
             mode (bool): Specifies whether the primitive is recomputed. Default: ``True`` .
@@ -466,7 +450,7 @@ class Primitive(Primitive_):
         Examples:
             >>> import numpy as np
             >>> import mindspore as ms
-            >>> from mindspore import Tensor, ops, nn
+            >>> from mindspore import Tensor, ops, nn, jit
             >>> class NetRecompute(nn.Cell):
             ...     def __init__(self):
             ...         super(NetRecompute,self).__init__()
@@ -481,6 +465,7 @@ class Primitive(Primitive_):
             ...         super(GradNet,self).__init__()
             ...         self.network = network
             ...         self.grad = ops.GradOperation()
+            ...     @jit
             ...     def construct(self, x):
             ...         g_out = self.grad(self.network)(x)
             ...         return g_out
@@ -492,8 +477,6 @@ class Primitive(Primitive_):
             >>> print(a)
             [0. 0.5]
         """
-        if context.get_context("mode") == context.PYNATIVE_MODE:
-            raise TypeError("Recompute is not supported in pynative mode currently.")
         Validator.check_bool(mode)
         self.add_prim_attr("recompute", mode)
         return self
@@ -510,8 +493,6 @@ class Primitive(Primitive_):
         Args:
             backward_prefetch(Union[str, int]): Specifies whether the activation is prefetched in backward pass.
         """
-        if context.get_context("mode") == context.PYNATIVE_MODE:
-            raise ValueError("Offload is not supported in pynative mode currently.")
         self.add_prim_attr("offload", True)
         if isinstance(backward_prefetch, str):
             Validator.check_string(backward_prefetch, ['Auto'], 'backward_prefetch', 'Primitive._offload')
@@ -551,10 +532,6 @@ class Primitive(Primitive_):
         Validator.check_non_negative_int(rank_id, "rank_id", "Primitive.place")
         Validator.check_string(role, "MS_WORKER", "role", "Primitive.place")
 
-        if context.get_context("mode") == context.PYNATIVE_MODE:
-            raise RuntimeError("You are calling Primitive.place in pynative mode."
-                               "It's only supported in graph mode. Please switch to graph mode.")
-
         # Get the execution context and check whether calling of this 'place' method is valid.
         # This is because placing operators to arbitrary processes while other distributed training mode
         # is enabled is very unpredictable and may cause fatal error.

mindspore/ops/tensor_method.py

@@ -24,8 +24,7 @@ from mindspore.ops.composite.multitype_ops._compile_utils import (
     sequence_to_tensor, _tensor_sub, _tensor_pow, _tensor_div, _tensor_floordiv, _tensor_mod
 )
 from mindspore.ops.auto_generate.gen_ops_prim import (
-    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op,
-    inplace_copy_op
+    inplace_scatter_src_op, inplace_scatter_src_reduce_op, inplace_scatter_value_op, inplace_scatter_value_reduce_op
 )
 from mindspore.ops.auto_generate.gen_ops_prim import (
     floor_div_op, floor_div_scalar_op
@@ -240,6 +239,7 @@ from mindspore.ops.function.array_func import tensor_scatter_add
 from mindspore.ops.auto_generate import select, select_ext_view
 # 94 sigmoid
 from mindspore.ops.auto_generate import sigmoid
+from mindspore.ops.auto_generate import inplace_sigmoid as sigmoid_
 # 95 sin
 from mindspore.ops.auto_generate import sin
 # 96 size
@@ -367,7 +367,7 @@ from mindspore.ops.auto_generate import acos_ext, acosh_ext, asin_ext, asinh_ext
 from mindspore.ops.function.math_func import median
 
 # 156
-
+from mindspore.ops.function.math_func import permute
 # 157
 from mindspore.ops.auto_generate import xlogy_op
 
@@ -442,6 +442,9 @@ from mindspore.ops.auto_generate.gen_ops_prim import inplace_exp_op
 # 1030 log_
 from mindspore.ops.auto_generate.gen_ops_prim import inplace_log_op
 
+# 1031 masked_scatter
+from mindspore.ops.auto_generate import masked_scatter
+
 from .._checkparam import check_axis_in_range
 from ..ops.composite.multitype_ops import _compile_utils as compile_utils
 
@@ -1038,6 +1041,10 @@ def tensor_sigmoid(input):
     return sigmoid(input)
 
 
+def tensor_sigmoid_(input):
+    return sigmoid_(input)
+
+
 # 95 sin
 def tensor_sin(input):
     return sin(input)
@@ -1135,6 +1142,7 @@ def deprecated_tensor_sum(input, axis=None, dtype=None, keepdims=False, initial=
 
 # 105 swapaxes
 
+
 # 106 t
 def tensor_t(input):
     return t(input)
@@ -1163,6 +1171,7 @@ def deprecated_tensor_tile(input, reps):
 
 # 109 tolist
 
+
 # 110 topk
 def tensor_topk(input, k, dim=-1, largest=True, sorted=True):
     return topk(input, k, dim, largest, sorted)
@@ -1182,6 +1191,11 @@ def deprecated_tensor_transpose(input, *axes):
     return transpose(input, perm)
 
 
+def deprecated_tensor_permute(input, *axis):
+    perm = validator.check_transpose_axis(axis, input.ndim)
+    return permute(input, perm)
+
+
 # 112 tril
 def deprecated_tensor_tril(input, diagonal=0):
     return tril(input, diagonal)
@@ -1194,6 +1208,7 @@ def tensor_trunc(input):
 
 # 114 type
 
+
 # 115 type_as
 def deprecated_tensor_type_as(input, other):
     return input.astype(other.dtype)
@@ -1453,14 +1468,10 @@ def tensor_atanh(input):
     return F.atanh(input)
 
 
-def tensor_copy_(input, src):
+def tensor_copy_(input, src, non_blocking=False):
     raise ValueError("should not come here for copy_ method")
 
 
-def deprecated_tensor_copy_(input, src, non_blocking=False):
-    return inplace_copy_op(input, src)
-
-
 def tensor_tan(input):
     return F.tan(input)
 
@@ -1513,12 +1524,18 @@ def deprecated_tensor_logaddexp2(input, other):
 
 
 # 157
-def tensor_empty(*size, dtype=None, device=None):
+def tensor_empty(*size, dtype=None, device=None, pin_memory=False):
+    r"""
+    For details, please refer to :func:`mindspore.mint.empty`.
+    """
     logger.error(
         "This is a function for empty not should be called. Please check the implementation.")
 
 
-def tensor_empty_like(input, *, dtype=None, device=None):
+def tensor_empty_like(input, *, dtype=None, device=None, pin_memory=False):
+    """
+    For details, please refer to :func:`mindspore.mint.empty_like`.
+    """
     raise NotImplementedError(
         "This is a function for empty_like should not be called. Please check the implementation.")
 
@@ -1813,10 +1830,19 @@ def deprecated_tensor_var(input, axis=None, ddof=0, keepdims=False):
     return _tensor_div(x_sum, nums - ddof)
 
 
+# 1222
+def tensor_index_fill_(input, dim, index, value):
+    raise NotImplementedError('Tensor.index_fill_ only supports Ascend.')
+
+
 def tensor_kthvalue(input, k, dim=-1, keepdim=False):
     raise ValueError("should not come here for kthvalue py_method.")
 
 
+def tensor_index_copy_(input, dim, index, tensor):
+    raise NotImplementedError('Tensor.index_copy_ only supports Ascend.')
+
+
 def tensor_sub_empty_(input, other, alpha=1):
     raise ValueError("should not come here for sub_ method.")
 
@@ -1826,9 +1852,11 @@ def tensor_inplace_sub(input, other, *, alpha=1):
         return sub(input, other)
     return sub_ext(input, other, alpha=alpha)
 
+
 def tensor_new_full(input, size, fill_value, *, dtype=None):
     raise NotImplementedError("new_full method support Ascend only")
 
+
 def tensor_div_empty_(input, other, rounding_mode=None):
     raise ValueError("should not come here for div_ method.")
 
@@ -1860,10 +1888,18 @@ def all_gather_matmul(
     raise NotImplementedError('all_gather_matmul only supports Ascend.')
 
 
+def conv1d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
+    raise NotImplementedError('conv1d only supports Ascend.')
+
+
 def conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
     raise NotImplementedError('conv3d only supports Ascend.')
 
 
+def tensor_remainder_(input, other):
+    return _tensor_mod(input, other)
+
+
 def tensor_floor_divide_(input, other):
     return _tensor_floordiv(input, other)
 
@@ -1908,6 +1944,10 @@ def tensor_gelu(input, *, approximate):
     return gelu(input, approximate)
 
 
+def tensor_bernoulli_(input, p, seed, offset):
+    raise RuntimeError("'bernoulli_' is not supported on this device.")
+
+
 def deprecated_pixel_shuffle(input, upscale_factor):
     return F.pixel_shuffle(input, upscale_factor)
 
@@ -1920,8 +1960,46 @@ def tensor_quant_matmul(x1, x2, scale, *, offset=None, pertoken_scale=None, bias
     raise NotImplementedError('quant_matmul only supports Ascend.')
 
 
+def tensor_index(input, value):
+    raise NotImplementedError("index only supports Ascend.")
+
+
 def tensor_gmm(x, weight, *, bias=None, group_list=None, group_type=0, group_list_type=0):
     raise NotImplementedError("gmm has not been implemented by python.")
 
+
 def raise_func(*args, **kwargs):
     raise NotImplementedError("this func has not been implemented.")
+
+
+def tensor_masked_scatter(input, mask, source):
+    return masked_scatter(input, mask, source)
+
+
+def tensor_inplace_masked_scatter(input, mask, source):
+    return F.inplace_masked_scatter(input, mask, source)
+
+
+def tensor_broadcast_to(x, shape):
+    return F.broadcast_to(x, shape)
+
+def tensor_squeeze(input, axis=None):
+    return F.squeeze(input, axis)
+
+
+def conv2d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1):
+    raise NotImplementedError('conv2d only supports Ascend.')
+
+
+def tensor_real(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.real`.
+    """
+    return ops.real(input)
+
+
+def tensor_imag(input):
+    r"""
+    For details, please refer to :func:`mindspore.ops.imag`.
+    """
+    return ops.imag(input)

mindspore/ops_generate/aclnn/aclnn_kernel_register_auto_cc_generator.py

@@ -30,7 +30,7 @@ from resources.resource_list import ResourceType
 
 
 ACLNN_REG_CODE = """
-#include "$ops_gen_kernel_path/ascend/opapi/aclnn_kernel_mod.h"
+#include "$ops_gen_kernel_path/ascend/aclnn/kernel_mod_impl/aclnn_kernel_mod.h"
 
 namespace mindspore {
 namespace kernel {
@@ -88,14 +88,14 @@ class AclnnKernelRegisterAutoCcGenerator(BaseGenerator):
         res_str = template.CC_LICENSE_STR + reg_code
 
         save_path = os.path.join(
-            work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/opapi/auto_generate")
+            work_path, f"{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/auto_generate")
         file_name = "aclnn_kernel_register_auto.cc"
         gen_utils.save_file(save_path, file_name, res_str)
 
 
-def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
+def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/'):
     '''get registered ops by search files'''
-    # default search in 'ops/kernel/ascend/opapi/'
+    # default search in 'ops/kernel/ascend/aclnn/kernel_mod_impl/'
     search_path = os.path.join(K.WORK_DIR, file_path)
     ret = []
     try:
@@ -117,7 +117,7 @@ def get_registed_ops(file_path=f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/'):
 
 registed_ops = get_registed_ops()
 manual_registed_ops = get_registed_ops(
-    f'{K.MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+    f'{K.MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/customize/')
 
 
 def check_op_registed(op_name, manual=False):

mindspore/ops_generate/aclnn/gen_aclnn_implement.py

@@ -118,7 +118,7 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
         logging.warning("Kernel {%s} is already registered.", op_name)
         return
 
-    aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/'
+    aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/customize/'
     # merge inner ops
     dispatch = op_proto.op_dispatch
     aclnn_name = ''.join(word.capitalize() for word in op_name.split('_'))
@@ -130,7 +130,7 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
     if auto:
         auto_gen = "_auto_gen"
         kernelmod_name = aclnn_name + "Ascend"
-        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_auto_gen/'
+        aclnn_path = f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/aclnn_auto_gen/'
         pathlib.Path(os.path.join(K.WORK_DIR, aclnn_path)
                      ).mkdir(parents=True, exist_ok=True)
     if dispatch.ascend is None:
@@ -145,9 +145,9 @@ def gen_aclnn_kernel(op_proto: OpProto, need_update_shape=False, auto=False):
              kernelmod_h_and_cc_path, need_update_shape)
 
 
-def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
+def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/'):
     '''get registered ops by search files'''
-    # default search in 'ops/kernel/ascend/opapi/'
+    # default search in 'ops/kernel/ascend/aclnn/kernel_mod_impl/'
     search_path = os.path.join(K.WORK_DIR, file_path)
     ret = []
     try:
@@ -167,7 +167,7 @@ def get_registed_ops(file_path=f'{MS_OPS_KERNEL_PATH}/ascend/opapi/'):
 
 registed_ops = get_registed_ops()
 manual_registed_ops = get_registed_ops(
-    f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn/')
+    f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/customize/')
 
 
 def check_op_registed(op_name, manual=False):
@@ -182,7 +182,7 @@ def generate_aclnn_reg_code(yaml_data):
     yaml_str = gen_utils.safe_load_yaml(ops_yaml_path)
 
     reg_code = f"""
-#include "{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_mod.h"
+#include "{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/aclnn_kernel_mod.h"
 
 namespace mindspore {{
 namespace kernel {{
@@ -224,9 +224,9 @@ def generate_aclnn_reg_file(work_path, yaml_str):
     Generate nnacl kernelmod register
     """
     tmp_register_file = work_path + \
-        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/tmp_aclnn_kernel_register.cc'
+        f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/tmp_aclnn_kernel_register.cc'
     register_file = work_path + \
-        f'{MS_OPS_KERNEL_PATH}/ascend/opapi/aclnn_kernel_register_auto.cc'
+        f'{MS_OPS_KERNEL_PATH}/ascend/aclnn/kernel_mod_impl/aclnn_kernel_register_auto.cc'
     reg_code = generate_aclnn_reg_code(yaml_str)
     gen_utils.save_file(
         os.path.dirname(tmp_register_file), os.path.basename(tmp_register_file), gen_utils.cc_license_str + reg_code)

mindspore/ops_generate/api/functions_cc_generator.py

@@ -23,6 +23,7 @@ from common.template import Template
 import common.gen_constants as K
 from common.gen_utils import save_file
 from common.base_generator import BaseGenerator
+from pyboost.op_template_parser import OpTemplateParser
 from pyboost.pyboost_utils import is_optional_param, get_input_dtype, get_return_type
 
 
@@ -39,7 +40,7 @@ class FunctionsHeaderGenerator(BaseGenerator):
         self.function_interface_template = Template("${return_type} BACKEND_EXPORT ${op_name}(${input_args});")
         self.function_interface_template_comm = Template(
             "${return_type} BACKEND_EXPORT ${op_name}_inner(${input_args}," \
-            "CommHandlePtr comm_handle, const std::string& target);"
+            "CommHandlePtr comm_handle, device::DeviceType target);"
         )
         self.function_interface_template_comm_return_handle = Template(
             "${return_type_with_handle} BACKEND_EXPORT ${op_name}(${input_args});"
@@ -112,10 +113,15 @@ class FunctionsGenerator(BaseGenerator):
         """
         self.FUNCTIONS_CC_TEMPLATE = template.FUNCTIONS_CC_TEMPLATE
         self.FUNCTION_BODY_TEMPLATE = template.FUNCTION_BODY_TEMPLATE
+        self.FUNCTION_VIEW_BODY_TEMPLATE = template.FUNCTION_VIEW_BODY_TEMPLATE
+        self.FUNCTION_VIEW_CUSTOMIZE_BODY_TEMPLATE = template.FUNCTION_VIEW_CUSTOMIZE_BODY_TEMPLATE
         self.FUNCTION_COMM_BODY_TEMPLATE = template.FUNCTION_COMM_BODY_TEMPLATE
         self.pyboost_func_include_header_template = Template(
             f'#include "{K.MS_PYBOOST_BASE_PATH}/auto_generate/${{operator_name}}.h"\n'
         )
+        self.pyboost_view_func_include_header_template = Template(
+            f'#include "{K.MS_OPS_VIEW_PATH}/${{operator_name}}_strides_calc.h"\n'
+        )
         self.clone_inplace_input_template = Template(
             'GetCloneFunc()(op, prim::kPrim${class_name}, device_target, {${grad_args}});'
         )
@@ -140,9 +146,14 @@ class FunctionsGenerator(BaseGenerator):
         for op_proto in op_protos:
             if op_proto.op_dispatch is None:
                 continue
-            func_include_headers_list.append(
-                self.pyboost_func_include_header_template.replace(operator_name=op_proto.op_name))
-            op_call_with_grad_list.append(self._get_function_body(op_proto))
+            if op_proto.op_view:
+                function_body, pyboost_func_include_header = self._get_function_view_body(op_proto)
+            else:
+                pyboost_func_include_header = self.pyboost_func_include_header_template.\
+                    replace(operator_name=op_proto.op_name)
+                function_body = self._get_function_body(op_proto)
+            func_include_headers_list.append(pyboost_func_include_header)
+            op_call_with_grad_list.append(function_body)
             ops_inc_head_set.add(
                 template.OP_DEF_INC_HEAD_TEMPLATE.replace(prefix_char=op_proto.op_class.name[0].lower()))
         pyboost_func_h_str = self.FUNCTIONS_CC_TEMPLATE.replace(op_call_with_grad=op_call_with_grad_list,
@@ -152,6 +163,44 @@ class FunctionsGenerator(BaseGenerator):
         file_name = "functions.cc"
         save_file(save_path, file_name, pyboost_func_h_str)
 
+    def _get_function_view_body(self, op_proto):
+        """
+        Get the function body for a given view operator prototype.
+
+        Args:
+            op_proto: The operator prototype.
+
+        Returns:
+            str: The generated function body.
+        """
+        function_body_template = self.FUNCTION_VIEW_BODY_TEMPLATE
+        pyboost_func_include_header = self.pyboost_view_func_include_header_template.\
+            replace(operator_name=op_proto.op_name)
+        if not op_proto.bprop_expander or op_proto.op_name in ["reshape"]:
+            function_body_template = self.FUNCTION_VIEW_CUSTOMIZE_BODY_TEMPLATE
+            pyboost_func_include_header = ""
+        op_parser = OpTemplateParser(op_proto)
+        input_args = self._get_input_args(op_proto, False)
+        input_args_with_type = self._get_input_args(op_proto, True)
+        call_args_with_type = op_parser.parse_call_args_with_types(True)
+        call_args = OpTemplateParser.parse_original_call_args(op_proto.op_args)
+        call_args_tensors = op_parser.get_call_args_tensor()
+        storage_calc_str = op_proto.op_class.name
+        return_values, _ = op_parser.generate_pyboost_outputs()
+        return_type_str = _get_return_type_str(op_proto)
+        function_body = function_body_template.replace(op_name=op_proto.op_name,
+                                                       class_name=op_proto.op_class.name,
+                                                       input_args_with_type=input_args_with_type,
+                                                       input_args=input_args,
+                                                       storage_calc=storage_calc_str,
+                                                       call_args_with_type=call_args_with_type,
+                                                       call_args=call_args,
+                                                       call_tensors=call_args_tensors,
+                                                       input=call_args[0],
+                                                       return_values=return_values,
+                                                       return_type=return_type_str)
+        return function_body, pyboost_func_include_header
+
     def _get_function_body(self, op_proto):
         """
         Get the function body for a given operator prototype.