mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc2__cp38-cp38-manylinux1_x86_64.whl

mindspore/gen_ops.py

@@ -1,273 +0,0 @@
-# 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/nn/layer/flash_attention.py

@@ -1,189 +0,0 @@
-# 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.
-# ============================================================================
-"""
-A FlashAttention Layer.
-"""
-import math
-
-import mindspore.common.dtype as mstype
-from mindspore.common.tensor import Tensor
-from mindspore import ops
-from mindspore.nn.cell import Cell
-from mindspore.ops.operations.nn_ops import FlashAttentionScore
-
-__all__ = ['FlashAttention']
-
-
-class FlashAttention(Cell):
-    """Flash Attention Layer.
-
-    This function contains the flash attention primitives used in FlashAttention (see paper)
-    `FlashAttention: Fast and Memory-Efficient Exact Attention with IO-Awareness <https://arxiv.org/pdf/2205.14135.pdf>`
-
-    Specifically, it includes the following:
-
-    1. An interface for calling flashattention operation.
-    2. Two configuration parameters for enabling local block sparse of flashattention.
-
-    Args:
-        head_dim(int): The hidden size of input.
-        dropout_rate(float): The dropout rate of the attention score. Default 0.0.
-        prev_block_num(int): A integer to define the number of blocks to look ahead for local block sparse attention.
-            Default 65536.
-        next_block_num(int): A integer to define the number of blocks to look behind for local block sparse attention.
-            Default 65536.
-        dp(int): data parallel.
-            Default 1.
-        mp(int): model parallel.
-            Default 1.
-        high_precision(bool): This mode has higher precision but some performance loss. Only take effect on Ascend910A.
-            Default False.
-        have_attention_mask_batch(bool): indicates whether attention_mask contains the batch dimension.
-            Default True
-        alibi(bool): This parameter indicates whether the flashattention supports the Alibi.
-            Default: False
-        use_mqa(bool): Using MQA if True, only take effect under 910B. Default: False.
-
-
-    Inputs:
-      - **query** (Tensor) - Tensor query (:class:`mstype.fp16` [batch_size, head_num, seq_length, head_dim])
-      - **key** (Tensor) - Tensor key (:class:`mstype.fp16` [batch_size, head_num, seq_length, head_dim])
-      - **value** (Tensor) - Tensor value (:class:`mstype.fp16` [batch_size, head_num, seq_length, head_dim])
-      - **attention_mask** (Tensor) - Float Tensor the mask of (:class:`mstype.fp16` `mstype.uint8`
-        [batch_size, seq_length, seq_length]): A matrix to pass masked information.
-
-    Outputs:
-        A Tensor. The output of the attention with shape [batch_size, head_num, seq_length, head_dim]
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import dtype as mstype
-        >>> from mindspore.nn.layer.flash_attention import FlashAttention
-        >>> from mindspore import Tensor
-        >>> model = FlashAttention(head_dim=128,
-        ...                        dropout_rate=0.1,
-        ...                        prev_block_num=7,
-        ...                        next_block_num=0
-        ...                        )
-        >>> query = Tensor(np.ones((2, 16, 4096, 128)), mstype.float16)
-        >>> key = Tensor(np.ones((2, 16, 4096, 128)), mstype.float16)
-        >>> value = Tensor(np.ones((2, 16, 4096, 128)), mstype.float16)
-        >>> attention_mask = Tensor(np.ones((2, 4096, 4096)), mstype.float16)
-        >>> output = model(query, key, value, attention_mask)
-        >>> print(output.shape)
-        (2, 16, 4096, 128)
-    """
-
-    def __init__(self,
-                 head_dim,
-                 head_num,
-                 dropout_rate=0.0,
-                 prev_block_num=65536,
-                 next_block_num=65536,
-                 dp=1,
-                 mp=1,
-                 high_precision=False,
-                 have_attention_mask_batch=True,
-                 alibi=False,
-                 use_mqa=False
-                 ):
-        super(FlashAttention, self).__init__()
-
-        scaling_constant = math.sqrt(head_dim)
-        if scaling_constant == 0:
-            raise ValueError("the scaling constant must not be 0.")
-        self.dropout_rate = dropout_rate
-        self.alibi = alibi
-        self.have_attention_mask_batch = have_attention_mask_batch
-
-        self.transpose_4d_pre = ops.Transpose().shard(((dp, mp, 1, 1),))
-        self.transpose_4d_post = ops.Transpose().shard(((dp, 1, mp, 1),))
-        self.reshape = ops.Reshape()
-        self.zeros_like = ops.ZerosLike().shard(((dp, mp, 1, 1),))
-        self.zeros = ops.Zeros()
-        self.attn_cast = ops.Cast()
-        if use_mqa:
-            fa_strategies = ((dp, mp, 1, 1),
-                             (dp, 1, 1, 1),
-                             (dp, 1, 1, 1))
-        else:
-            fa_strategies = ((dp, mp, 1, 1),
-                             (dp, mp, 1, 1),
-                             (dp, mp, 1, 1))
-        if self.alibi:
-            self.alibi_rescale_mul = ops.Mul().shard(((dp, mp, 1, 1), (1,)))
-            self.alibi_rescale_factor = Tensor([scaling_constant], dtype=mstype.float16)
-            fa_strategies += ((dp, mp, 1, 1),)
-        if dropout_rate > 1e-5:
-            fa_strategies += ((dp, mp, 1, 1),)
-        fa_strategies += ((dp, 1, 1, 1),)
-        self.flash_attention = FlashAttentionScore(head_num=head_num, pre_tokens=prev_block_num,
-                                                   next_tokens=next_block_num,
-                                                   keep_prob=1 - dropout_rate,
-                                                   scale_value=1. / scaling_constant,
-                                                   inner_precise=0,
-                                                   input_layout="BNSD").shard(fa_strategies)
-
-        self.dropout_rate = dropout_rate
-        if self.dropout_rate > 1e-5:
-            self.keep_prob = Tensor(1 - self.dropout_rate, dtype=mstype.float16)
-            self.fill_v2 = ops.FillV2().shard(((dp, mp, 1, 1), ()))
-            self.tensor_one = Tensor(1.0, mstype.float16)
-            self.drop_gen_mask = ops.DropoutGenMask()
-            self.do_dropout = ops.DropoutDoMask().shard(((dp, mp, 1, 1),))
-            self.depend = ops.Depend()
-
-    def shard(self, in_strategy=None, out_strategy=None):
-        """Distributed configuration of FlashAttention
-        :param in_strategy: Describe the split strategy of operator input. Default: None.
-        :param out_strategy: Describe the split strategy of operator output, it is only for certain operators,
-                                  such as MatMul. Default: None.
-        :return:
-        """
-        self.flash_attention.shard(in_strategy)
-
-    def construct(self, query, key, value, attn_mask=None, alibi_mask=None):
-        """FlashAttention forward
-        :param query:           [bsz, head_num, seq_len, head_dim]
-        :param key:           [bsz, head_num, seq_len, head_dim]
-        :param value:           [bsz, head_num, seq_len, head_dim]
-        :param attn_mask:   [1 or bsz, seq_len, seq_len], if not None
-        :param alibi_mask: [bsz, head_num, 1, seq_len], if not None
-        :return: output          [bsz, head_num, seq_len, head_dim]
-        """
-        bsz, head_num, seq_len, _ = query.shape
-        # 910B -- FlashAttentionScore
-        if self.dropout_rate > 1e-5:
-            drop_mask_bits = self.reshape(self.drop_gen_mask((bsz, head_num, seq_len, seq_len), self.keep_prob),
-                                          (bsz, head_num, seq_len, seq_len // 8))
-        else:
-            drop_mask_bits = None
-        if self.alibi:
-            alibi_mask = self.alibi_rescale_mul(alibi_mask, self.cast(self.alibi_rescale_factor, alibi_mask.dtype))
-        # (B, S, S) -> (B, 1, S, S)
-        if self.have_attention_mask_batch:
-            attn_mask = self.cast(self.reshape(attn_mask, (bsz, 1, seq_len, seq_len)), mstype.uint8)
-        _, _, _, output = self.flash_attention(query,
-                                               key,
-                                               value,
-                                               alibi_mask,
-                                               drop_mask_bits,
-                                               None,
-                                               attn_mask,
-                                               None)
-        return output

mindspore/ops/_op_impl/cpu/concat.py

@@ -1,39 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-"""Concat op"""
-from mindspore.ops.op_info_register import op_info_register, CpuRegOp, DataType
-
-concat_op_info = CpuRegOp("Concat") \
-    .input(0, "x", "required") \
-    .output(0, "y", "required") \
-    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.F64_Default, DataType.F64_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I8_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I16_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U8_Default, DataType.U8_Default) \
-    .dtype_format(DataType.U16_Default, DataType.U16_Default) \
-    .dtype_format(DataType.U32_Default, DataType.U32_Default) \
-    .dtype_format(DataType.U64_Default, DataType.U64_Default) \
-    .dtype_format(DataType.BOOL_Default, DataType.BOOL_Default) \
-    .get_op_info()
-
-
-@op_info_register(concat_op_info)
-def _concat_cpu():
-    """Concat cpu register"""
-    return

mindspore/ops/_op_impl/cpu/tensor_shape.py

@@ -1,42 +0,0 @@
-# Copyright 2022-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.
-# ============================================================================
-
-"""DynamicShape op"""
-from mindspore.ops.op_info_register import op_info_register, CpuRegOp, DataType
-
-tensor_shape_op_info = CpuRegOp("TensorShape") \
-    .input(0, "x", "required") \
-    .output(0, "y", "required") \
-    .dtype_format(DataType.F16_Default, DataType.I64_Default) \
-    .dtype_format(DataType.F32_Default, DataType.I64_Default) \
-    .dtype_format(DataType.F64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I64_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I64_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I64_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U16_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U32_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.BOOL_Default, DataType.I64_Default) \
-    .dtype_format(DataType.C64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.C128_Default, DataType.I64_Default) \
-    .get_op_info()
-
-
-@op_info_register(tensor_shape_op_info)
-def _tensor_shape_cpu():
-    """DynamicShape cpu register"""
-    return

mindspore/ops/_op_impl/tbe/__init__.py

@@ -1,47 +0,0 @@
-# Copyright 2020-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.
-# ============================================================================
-
-"""tbe ops"""
-from .broadcast_to import _broadcast_to_tbe  # The name is occupied
-from .broadcast_to_ds import _broadcast_to_ds_tbe  # The name is occupied
-from .batch_to_space import _batch_to_space_tbe  # attr type is listInt, not listListInt
-from .batch_to_space_nd import _batch_to_space_nd_tbe  # attr type is listInt, not listListInt
-from .batch_to_space_nd_v2 import _batch_to_space_nd_v2_tbe  # The name is occupied
-from .space_to_batch import _space_to_batch_tbe  # attr type is listInt, not listListInt
-from .space_to_batch_nd import _space_to_batch_nd_tbe  # attr type is listInt, not listListInt
-from .dynamic_gru_v2 import _dynamic_gru_v2_tbe  # input4 is None, GE will change to hidden op by pass
-from .dynamic_rnn import _dynamic_rnn_tbe  # input4 is None, GE will change to hidden op by pass
-from .kl_div_loss_grad import _kl_div_loss_grad_tbe  # Accuracy issues
-from .inplace_index_add import _inplace_index_add_tbe  # check support failed if var has only one dimension
-from .scatter_nd_update_ds import _scatter_nd_update_ds_tbe  # not support int8 in op json
-from .scatter_nd_add import _scatter_nd_add_tbe  # not support int8 in op json
-from .cast_ds import _cast_ds_tbe  # Accuracy issues
-from .avg_pool_3d_grad import _avg_pool_3d_grad_tbe  # Second device format is facz_3d, but in json, the key is ndhwc
-from .data_format_dim_map_ds import _data_format_dim_map_ds_tbe  # attr order swap
-from .depthwise_conv2d import _depthwise_conv2d_tbe  # Accuracy issues(second format is error in python)
-from .acos import _acos_tbe # Accuracy issues(task error in parallel)
-from .trans_data_ds import _trans_data_ds_tbe # performance and accuracy
-from .scatter_nd_d import _scatter_nd_d_tbe # in python no check supported
-from .assign_add_ds import _assign_add_ds_tbe # "Frac_nz in pangu not support"
-from .atomic_addr_clean import _atomic_addr_clean_tbe # need to clean addr larger than 2G, int32 is not enough
-from .mem_set import _mem_set_tbe # need to clean addr larger than 2G, int32 is not enough
-from .assign import _assign_tbe # Different formats of assign inputs cause memory to increase
-from .npu_clear_float_status_v2 import _npu_clear_float_status_v2_tbe  # io mismatch
-from .npu_get_float_status_v2 import _npu_get_float_status_v2_tbe  # io mismatch
-from .tensor_move import _tensor_move_tbe # not support uint32 in op json
-from .bn_infer_grad import _bn_infer_grad_tbe
-from .avg_pool import _avg_pool_tbe
-from .gather_nd import _gather_nd_tbe
-from .bn_infer_ds import _bn_infer_ds_tbe

mindspore/ops/_op_impl/tbe/abs.py

@@ -1,38 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-"""Abs op"""
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
-
-abs_op_info = TBERegOp("Abs") \
-    .fusion_type("ELEMWISE") \
-    .async_flag(False) \
-    .binfile_name("abs.so") \
-    .compute_cost(10) \
-    .kernel_name("abs") \
-    .partial_flag(True) \
-    .op_pattern("formatAgnostic") \
-    .input(0, "x", None, "required", None) \
-    .output(0, "y", True, "required", "all") \
-    .dtype_format(DataType.F16_None, DataType.F16_None) \
-    .dtype_format(DataType.F32_None, DataType.F32_None) \
-    .dtype_format(DataType.I32_None, DataType.I32_None) \
-    .get_op_info()
-
-
-@op_info_register(abs_op_info)
-def _abs_tbe():
-    """Abs TBE register"""
-    return

mindspore/ops/_op_impl/tbe/abs_ds.py

@@ -1,39 +0,0 @@
-# Copyright 2021 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-"""Abs op"""
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
-
-abs_op_info = TBERegOp("Abs") \
-    .fusion_type("ELEMWISE") \
-    .async_flag(False) \
-    .binfile_name("abs.so") \
-    .compute_cost(10) \
-    .kernel_name("abs") \
-    .partial_flag(True) \
-    .dynamic_shape(True) \
-    .op_pattern("formatAgnostic") \
-    .input(0, "x", None, "required", None) \
-    .output(0, "y", True, "required", "all") \
-    .dtype_format(DataType.F16_None, DataType.F16_None) \
-    .dtype_format(DataType.F32_None, DataType.F32_None) \
-    .dtype_format(DataType.I32_None, DataType.I32_None) \
-    .get_op_info()
-
-
-@op_info_register(abs_op_info)
-def _abs_ds_tbe():
-    """Abs TBE register"""
-    return