mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.whl

mindspore/ops/_op_impl/{tbe/scatter_add_ds.py → aicpu/inplace_index_add.py}

@@ -1,4 +1,4 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
+# Copyright 2022 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,31 +13,27 @@
 # limitations under the License.
 # ============================================================================
 
-"""ScatterAdd op"""
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
+"""InplaceIndexAdd op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
 
-scatter_add_ds_op_info = TBERegOp("ScatterAdd") \
-    .fusion_type("ELEMWISE") \
-    .async_flag(False) \
-    .binfile_name("scatter_add.so") \
-    .compute_cost(10) \
-    .kernel_name("scatter_add") \
-    .partial_flag(True) \
-    .dynamic_shape(True) \
-    .attr("use_locking", "optional", "bool", "all") \
-    .input(0, "var", False, "required", "all") \
-    .input(1, "indices", False, "required", "all") \
-    .input(2, "updates", False, "required", "all") \
-    .output(0, "var", False, "required", "all") \
+inplace_index_add_op_info = AiCPURegOp("InplaceIndexAdd") \
+    .fusion_type("OPAQUE") \
+    .attr("axis", "int")\
+    .input(0, "var", "required") \
+    .input(1, "indices", "required") \
+    .input(2, "updates", "required") \
+    .output(0, "var", "required") \
     .dtype_format(DataType.F16_Default, DataType.I32_Default, DataType.F16_Default, DataType.F16_Default) \
     .dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default, DataType.I8_Default) \
+    .dtype_format(DataType.F64_Default, DataType.I32_Default, DataType.F64_Default, DataType.F64_Default) \
     .dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default, DataType.U8_Default) \
+    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default, DataType.I8_Default) \
+    .dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I16_Default, DataType.I16_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
     .get_op_info()
 
 
-@op_info_register(scatter_add_ds_op_info)
-def _scatter_add_ds_tbe():
-    """ScatterAdd TBE register"""
+@op_info_register(inplace_index_add_op_info)
+def _inplace_index_add_aicpu():
+    """InplaceIndexAdd aicpu register"""
     return

mindspore/ops/_op_impl/aicpu/instance_norm_v2.py

@@ -0,0 +1,41 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""InstanceNormV2 op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+instance_norm_v2_op_info = AiCPURegOp("InstanceNormV2") \
+    .fusion_type("OPAQUE") \
+    .attr("is_training", "bool", "true") \
+    .attr("momentum", "float", "0.1") \
+    .attr("epsilon", "float", "0.00001") \
+    .input(0, "x", "required") \
+    .input(1, "gamma", "required") \
+    .input(2, "beta", "required") \
+    .input(3, "mean", "required") \
+    .input(4, "variance", "required") \
+    .output(0, "y", "required") \
+    .output(1, "batch_mean", "required") \
+    .output(2, "batch_variance", "required") \
+    .dtype_format(DataType.F16_Default, DataType.F32_Default, DataType.F32_Default, DataType.F32_Default,
+                  DataType.F32_Default, DataType.F16_Default, DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, DataType.F32_Default,
+                  DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, DataType.F32_Default) \
+    .get_op_info()
+
+
+@op_info_register(instance_norm_v2_op_info)
+def _instance_norm_v2_aicpu():
+    """InstanceNormV2 AiCPU register"""
+    return

mindspore/ops/_op_impl/aicpu/instance_norm_v2_grad.py

@@ -0,0 +1,44 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""InstanceNormV2Grad op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+instance_norm_v2_grad_op_info = AiCPURegOp("InstanceNormV2Grad") \
+    .fusion_type("OPAQUE") \
+    .attr("is_training", "bool", "true") \
+    .attr("epsilon", "float", "0.00001") \
+    .input(0, "dy", "required") \
+    .input(1, "x", "required") \
+    .input(2, "gamma", "required") \
+    .input(3, "mean", "required") \
+    .input(4, "variance", "required") \
+    .input(5, "save_mean", "required") \
+    .input(6, "save_variance", "required") \
+    .output(0, "pd_x", "required") \
+    .output(1, "pd_gamma", "required") \
+    .output(2, "pd_beta", "required") \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, DataType.F32_Default,
+                  DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, DataType.F32_Default,
+                  DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default, DataType.F32_Default, DataType.F32_Default,
+                  DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, DataType.F16_Default,
+                  DataType.F32_Default, DataType.F32_Default) \
+    .get_op_info()
+
+
+@op_info_register(instance_norm_v2_grad_op_info)
+def _instance_norm_v2_grad_aicpu():
+    """InstanceNormV2Grad AiCPU register"""
+    return

mindspore/ops/_op_impl/aicpu/layer_norm_grad_grad.py

@@ -0,0 +1,47 @@
+# 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.
+# ============================================================================
+
+
+"""LayerNormGradGrad op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+layernorm_grad_grad_op_info = AiCPURegOp("LayerNormGradGrad") \
+    .fusion_type("OPAQUE") \
+    .input(0, "x", "required")\
+    .input(1, "dy", "required") \
+    .input(2, "variance", "required")\
+    .input(3, "mean", "required") \
+    .input(4, "gamma", "required")\
+    .input(5, "d_dx", "required") \
+    .input(6, "d_dg", "required")\
+    .input(7, "d_db", "required") \
+    .output(0, "sopd_x", "required") \
+    .output(1, "sopd_dy", "required") \
+    .output(2, "sopd_gamma", "required") \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default, DataType.F16_Default, \
+                  DataType.F16_Default, DataType.F16_Default, DataType.F16_Default, \
+                  DataType.F16_Default, DataType.F16_Default, DataType.F16_Default, \
+                  DataType.F16_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, \
+                  DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, \
+                  DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, \
+                  DataType.F32_Default, DataType.F32_Default) \
+    .get_op_info()
+
+
+@op_info_register(layernorm_grad_grad_op_info)
+def _layernorm_grad_grad_aicpu():
+    """LayerNormGradGrad aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/less.py

@@ -0,0 +1,41 @@
+# 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.
+# ============================================================================
+
+"""Less op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+less_op_info = AiCPURegOp("Less")                                     \
+    .fusion_type("OPAQUE")                                                  \
+    .input(0, "x1", "required")                                             \
+    .input(1, "x2", "required")                                             \
+    .output(0, "y", "required")                                             \
+    .dtype_format(DataType.I8_Default, DataType.I8_Default, DataType.BOOL_Default)   \
+    .dtype_format(DataType.I16_Default, DataType.I16_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.I64_Default, DataType.I64_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.U8_Default, DataType.U8_Default, DataType.BOOL_Default)   \
+    .dtype_format(DataType.U16_Default, DataType.U16_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.U32_Default, DataType.U32_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.U64_Default, DataType.U64_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.BOOL_Default) \
+    .dtype_format(DataType.F64_Default, DataType.F64_Default, DataType.BOOL_Default) \
+    .get_op_info()
+
+
+@op_info_register(less_op_info)
+def _less_aicpu():
+    """Less AICPU register"""
+    return

mindspore/ops/_op_impl/aicpu/less_equal.py

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

mindspore/ops/_op_impl/aicpu/lgamma.py

@@ -0,0 +1,32 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Lgamma op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+lgamma_op_info = AiCPURegOp("Lgamma") \
+    .fusion_type("OPAQUE") \
+    .input(0, "x", "required") \
+    .output(0, "y", "required") \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.I32_Default, DataType.F32_Default) \
+    .get_op_info()
+
+
+@op_info_register(lgamma_op_info)
+def _lgamma_aicpu():
+    """Lgamma AiCPU register"""
+    return

mindspore/ops/_op_impl/aicpu/log_normal_reverse.py

@@ -0,0 +1,33 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""LogNormalReverse op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+log_normal_reverse_op_info = AiCPURegOp("LogNormalReverse") \
+    .fusion_type("OPAQUE") \
+    .attr("mean", "float")\
+    .attr("std", "float")\
+    .input(0, "input", "required") \
+    .output(0, "output", "required") \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+    .get_op_info()
+
+
+@op_info_register(log_normal_reverse_op_info)
+def _log_normal_reverse_aicpu():
+    """LogNormalReverse aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/logit.py

@@ -0,0 +1,33 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2022. All right reserved.
+#
+# 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.
+# ============================================================================
+
+"""Logit op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+logit_op_info = AiCPURegOp("Logit") \
+    .fusion_type("OPAQUE") \
+    .attr("eps", "float", "-1.0")\
+    .input(0, "x", "required") \
+    .output(0, "y", "required") \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F64_Default, DataType.F64_Default) \
+    .get_op_info()
+
+
+@op_info_register(logit_op_info)
+def _logit_aicpu():
+    """Logit aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/logit_grad.py

@@ -0,0 +1,34 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2022. All right reserved.
+#
+# 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.
+# ============================================================================
+
+"""LogitGrad op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+logit_grad_op_info = AiCPURegOp("LogitGrad") \
+    .fusion_type("OPAQUE") \
+    .attr("eps", "float", "-1") \
+    .input(0, "y_grad", "required") \
+    .input(1, "x", "required") \
+    .output(0, "x_grad", "required") \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F64_Default, DataType.F64_Default, DataType.F64_Default) \
+    .get_op_info()
+
+
+@op_info_register(logit_grad_op_info)
+def _logit_grad_aicpu():
+    """LogitGrad aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/masked_fill.py

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

mindspore/ops/_op_impl/aicpu/masked_scatter.py

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

mindspore/ops/_op_impl/aicpu/matmul.py

@@ -0,0 +1,39 @@
+# 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.
+# ============================================================================
+
+"""MatMul op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+matmul_op_info = AiCPURegOp("MatMul") \
+    .fusion_type("OPAQUE") \
+    .input(0, "x1", "required") \
+    .input(1, "x2", "required") \
+    .input(2, "bias", "optional") \
+    .output(0, "y", "required") \
+    .attr("transpose_x1", "bool", "false")\
+    .attr("transpose_x2", "bool", "false")\
+    .dtype_format(DataType.F16_Default, DataType.F16_Default, DataType.F16_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.F32_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F64_Default, DataType.F64_Default, DataType.F64_Default, DataType.F64_Default) \
+    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
+    .dtype_format(DataType.C64_Default, DataType.C64_Default, DataType.C64_Default, DataType.C64_Default) \
+    .dtype_format(DataType.C128_Default, DataType.C128_Default, DataType.C128_Default, DataType.C128_Default) \
+    .get_op_info()
+
+
+@op_info_register(matmul_op_info)
+def _matmul_aicpu():
+    """MatMul aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/matrix_logarithm.py

@@ -0,0 +1,31 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""MatrixLogarithm op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+matrix_logarithm_op_info = AiCPURegOp("MatrixLogarithm") \
+    .fusion_type("OPAQUE") \
+    .input(0, "x", "required") \
+    .output(0, "y", "required") \
+    .dtype_format(DataType.C64_Default, DataType.C64_Default) \
+    .dtype_format(DataType.C128_Default, DataType.C128_Default) \
+    .get_op_info()
+
+
+@op_info_register(matrix_logarithm_op_info)
+def _matrix_logarithm_aicpu():
+    """"MatrixLogarithm aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/matrix_power.py

@@ -0,0 +1,32 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""MatrixPower op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+matrix_power_op_info = AiCPURegOp("MatrixPower") \
+    .fusion_type("OPAQUE") \
+    .attr("n", "int") \
+    .input(0, "x", "required") \
+    .output(0, "y", "required") \
+    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
+    .get_op_info()
+
+
+@op_info_register(matrix_power_op_info)
+def _matrix_power_aicpu():
+    """MatrixPower aicpu register"""
+    return

mindspore/ops/_op_impl/aicpu/matrix_solve_ls.py

@@ -0,0 +1,36 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""MatrixSolveLs op"""
+from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
+
+matrix_solve_ls_op_info = AiCPURegOp("MatrixSolveLs") \
+    .fusion_type("OPAQUE") \
+    .attr("fast", "bool") \
+    .input(0, "matrix", "required") \
+    .input(1, "rhs", "required") \
+    .input(2, "l2", "required") \
+    .output(0, "y", "required") \
+    .dtype_format(DataType.F32_Default, DataType.F32_Default, DataType.F64_Default, DataType.F32_Default) \
+    .dtype_format(DataType.F64_Default, DataType.F64_Default, DataType.F64_Default, DataType.F64_Default) \
+    .dtype_format(DataType.C64_Default, DataType.C64_Default, DataType.F64_Default, DataType.C64_Default) \
+    .dtype_format(DataType.C128_Default, DataType.C128_Default, DataType.F64_Default, DataType.C128_Default) \
+    .get_op_info()
+
+
+@op_info_register(matrix_solve_ls_op_info)
+def _matrix_solve_ls_aicpu():
+    """MatrixSolveLs aicpu register"""
+    return