mindspore 2.1.0__cp38-cp38-win_amd64.whl → 2.2.11__cp38-cp38-win_amd64.whl

mindspore/_extends/graph_kernel/expanders/batchnorm_grad.py

@@ -1,105 +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.
-# ===========================================================================
-"""generate json desc for BatchNormGrad"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from ._utils import Expander, ExpanderInfoValidator as VLD
-from .expand_dims import ExpandDims
-
-
-@VLD.add_format(DF.NHWC, DF.NHWC, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT)
-@VLD.add_format(DF.NCHW, DF.NCHW, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT)
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT)
-@VLD.check_attrs('is_training', 'epsilon')
-class BatchNormGrad(Expander):
-    """BatchNormGrad expander"""
-
-    def _expand(self, graph_builder):
-        # get op info
-        input_dy = self.inputs[0]
-        input_x = self.inputs[1]
-        input_scale = self.inputs[2]
-        input_save_mean = self.inputs[3]
-        input_save_inv_variance = self.inputs[4]
-
-        reduce_axis = ()
-        shape_x = input_x.shape
-        if input_x.data_format == DF.NHWC:
-            reduce_axis = (0, 1, 2)
-            num = shape_x[0] * shape_x[1] * shape_x[2]
-        else:
-            reduce_axis = (0, 2, 3)
-            num = shape_x[0] * shape_x[2] * shape_x[3]
-        ori_type = input_x.dtype
-        if ori_type == 'float16':
-            input_x = graph_builder.emit('Cast', [input_x], attrs={'dst_type': 'float32'})
-        if input_dy.dtype == 'float16':
-            input_dy = graph_builder.emit('Cast', [input_dy], attrs={'dst_type': 'float32'})
-        num_rec = -1.0 / num
-        num_rec_v = graph_builder.value(input_scale.dtype, num_rec)
-        dbeta = graph_builder.emit('ReduceSum', [input_dy], attrs={'reduce_axis': reduce_axis, 'keep_dims': False})
-
-        # in training input_save_inv_variance means 1 / sqrt(variance + epsilon), which is calculated in forward pass
-        if self.attrs['is_training']:
-            inv_variance = input_save_inv_variance
-        else:
-            epsilon_v = graph_builder.value(input_scale.dtype, self.attrs['epsilon'])
-            var_add = graph_builder.emit('Add', [input_save_inv_variance, epsilon_v])
-            sqrt_var_eps = graph_builder.emit('Sqrt', [var_add])
-            scalar_one = 1.0
-            scalar_one_v = graph_builder.value(input_scale.dtype, scalar_one)
-            inv_variance = graph_builder.emit('RealDiv', [scalar_one_v, sqrt_var_eps])
-
-        # compute dgamma
-        if input_x.data_format in (DF.DEFAULT, DF.NCHW):
-            input_save_mean = graph_builder.emit(
-                'Reshape', [input_save_mean], attrs={'shape': ExpandDims.infer_shape(input_save_mean.shape, [-1, -1])})
-            inv_variance = graph_builder.emit(
-                'Reshape', [inv_variance], attrs={'shape': ExpandDims.infer_shape(inv_variance.shape, [-1, -1])})
-            input_scale = graph_builder.emit(
-                'Reshape', [input_scale], attrs={'shape': ExpandDims.infer_shape(input_scale.shape, [-1, -1])})
-        x_sub_mean = graph_builder.emit('Sub', [input_x, input_save_mean])
-        x_div = graph_builder.emit('Mul', [x_sub_mean, inv_variance])
-        dgamma_param = graph_builder.emit('Mul', [input_dy, x_div])
-        dgamma = graph_builder.emit(
-            'ReduceSum', [dgamma_param], attrs={'reduce_axis': reduce_axis, 'keep_dims': False})
-
-        # compute dx
-        if self.attrs['is_training']:
-            tmp_b = graph_builder.emit('Mul', [num_rec_v, dbeta])
-            if input_x.data_format in (DF.DEFAULT, DF.NCHW):
-                dgamma_expand = graph_builder.emit(
-                    'Reshape', [dgamma], attrs={'shape': ExpandDims.infer_shape(dgamma.shape, [-1, -1])})
-                tmp_b = graph_builder.emit(
-                    'Reshape', [tmp_b], attrs={'shape': ExpandDims.infer_shape(tmp_b.shape, [-1, -1])})
-            else:
-                dgamma_expand = dgamma
-            x_sub_mean_dgamma_mul = graph_builder.emit('Mul', [x_div, dgamma_expand])
-            tmp_c = graph_builder.emit('Mul', [num_rec_v, x_sub_mean_dgamma_mul])
-            tmp_ab_add = graph_builder.emit('Add', [input_dy, tmp_b])
-            tmp_abc_add = graph_builder.emit('Add', [tmp_ab_add, tmp_c])
-            gamma_mul = graph_builder.emit('Mul', [input_scale, tmp_abc_add])
-            dx = graph_builder.emit('Mul', [inv_variance, gamma_mul])
-        else:
-            y_scale = graph_builder.emit('Mul', [input_scale, input_dy])
-            dx = graph_builder.emit('Mul', [inv_variance, y_scale])
-        if ori_type == 'float16':
-            dx = graph_builder.emit('Cast', [dx], attrs={'dst_type': 'float16'})
-
-        # set output tensors' data_format
-        dx.data_format = self.outputs[0]['format']
-        dgamma.data_format = self.outputs[1]['format']
-        dbeta.data_format = self.outputs[2]['format']
-
-        return dx, dgamma, dbeta

mindspore/_extends/graph_kernel/expanders/clip_by_norm_no_div_sum.py

@@ -1,33 +0,0 @@
-# Copyright 2020-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.
-# ===========================================================================
-"""generate json desc for ClipByNormNoDivSum"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-class ClipByNormNoDivSum(Expander):
-    """ClipByNormNoDivSum expander"""
-
-    def _expand(self, graph_builder):
-        input_x0, input_x1, input_x2, input_x3 = self.inputs
-
-        # cal result
-        greater_res = graph_builder.emit('Greater', [input_x0, input_x1])
-        select_res0 = graph_builder.emit('Select', [greater_res, input_x0, input_x2])
-        sqrt_res = graph_builder.emit('Sqrt', [select_res0])
-        select_res1 = graph_builder.emit('Select', [greater_res, sqrt_res, input_x0])
-        result = graph_builder.emit('Maximum', [select_res1, input_x3])
-
-        return result

mindspore/_extends/graph_kernel/expanders/complex/abs.py

@@ -1,30 +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.
-# ===========================================================================
-"""generate json desc for cabs"""
-from mindspore._extends.graph_kernel.expanders._utils import Expander
-
-
-class CAbs(Expander):
-    """CAbs expander"""
-
-    def _expand(self, graph_builder):
-        input_x = self.inputs[0]
-        x_real = graph_builder.emit('CReal', [input_x])
-        x_imag = graph_builder.emit('CImag', [input_x])
-        squre_x_real = graph_builder.emit('Mul', [x_real, x_real])
-        squre_x_imag = graph_builder.emit('Mul', [x_imag, x_imag])
-        squre_sum = graph_builder.emit('Add', [squre_x_real, squre_x_imag])
-        result = graph_builder.emit('Sqrt', [squre_sum])
-        return result

mindspore/_extends/graph_kernel/expanders/complex/add.py

@@ -1,44 +0,0 @@
-# Copyright 2021-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.
-# ===========================================================================
-"""generate json desc for cadd"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from mindspore._extends.graph_kernel.expanders._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-class CAdd(Expander):
-    """CAdd expander"""
-
-    def _expand(self, graph_builder):
-        input_x, input_y = self.inputs
-        if input_x.dtype == input_y.dtype:
-            x_real = graph_builder.emit('CReal', [input_x])
-            y_real = graph_builder.emit('CReal', [input_y])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            result_real = graph_builder.emit('Add', [x_real, y_real])
-            result_imag = graph_builder.emit('Add', [x_imag, y_imag])
-            result = graph_builder.emit('Complex', [result_real, result_imag])
-        elif input_x.dtype == "complex64" or input_x.dtype == "complex128":
-            x_real = graph_builder.emit('CReal', [input_x])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            x_real_add_y = graph_builder.emit('Add', [x_real, input_y])
-            result = graph_builder.emit('Complex', [x_real_add_y, x_imag])
-        elif input_y.dtype == "complex64" or input_y.dtype == "complex128":
-            y_real = graph_builder.emit('CReal', [input_y])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            y_real_add_x = graph_builder.emit('Add', [y_real, input_x])
-            result = graph_builder.emit('Complex', [y_real_add_x, y_imag])
-        return result

mindspore/_extends/graph_kernel/expanders/complex/div.py

@@ -1,62 +0,0 @@
-# Copyright 2021-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.
-# ===========================================================================
-"""generate json desc for cdiv"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from mindspore._extends.graph_kernel.expanders._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-class CDiv(Expander):
-    """CDiv expander"""
-
-    def _expand(self, graph_builder):
-        """CDiv Implementation"""
-        input_x, input_y = self.inputs
-        if input_x.dtype == input_y.dtype:
-            x_real = graph_builder.emit('CReal', [input_x])
-            y_real = graph_builder.emit('CReal', [input_y])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            squre_y_real = graph_builder.emit('Mul', [y_real, y_real])
-            squre_y_imag = graph_builder.emit('Mul', [y_imag, y_imag])
-            final_denominator = graph_builder.emit('Add', [squre_y_real, squre_y_imag])
-            x_real_mul_y_real = graph_builder.emit('Mul', [x_real, y_real])
-            x_imag_mul_y_imag = graph_builder.emit('Mul', [x_imag, y_imag])
-            x_real_mul_y_imag = graph_builder.emit('Mul', [x_real, y_imag])
-            x_imag_mul_y_real = graph_builder.emit('Mul', [x_imag, y_real])
-            final_numerator_real = graph_builder.emit('Add', [x_real_mul_y_real, x_imag_mul_y_imag])
-            final_numerator_imag = graph_builder.emit('Sub', [x_imag_mul_y_real, x_real_mul_y_imag])
-            result_real = graph_builder.emit('RealDiv', [final_numerator_real, final_denominator])
-            result_imag = graph_builder.emit('RealDiv', [final_numerator_imag, final_denominator])
-            result = graph_builder.emit('Complex', [result_real, result_imag])
-        elif input_x.dtype == "complex64" or input_x.dtype == "complex128":
-            x_real = graph_builder.emit('CReal', [input_x])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            x_real_div_y = graph_builder.emit('RealDiv', [x_real, input_y])
-            x_imag_div_y = graph_builder.emit('RealDiv', [x_imag, input_y])
-            result = graph_builder.emit('Complex', [x_real_div_y, x_imag_div_y])
-        elif input_y.dtype == "complex64" or input_y.dtype == "complex128":
-            y_real = graph_builder.emit('CReal', [input_y])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            neg_y_imag = graph_builder.emit('Neg', [y_imag])
-            squre_y_real = graph_builder.emit('Mul', [y_real, y_real])
-            squre_y_imag = graph_builder.emit('Mul', [y_imag, y_imag])
-            final_denominator = graph_builder.emit('Add', [squre_y_real, squre_y_imag])
-            x_mul_y_real = graph_builder.emit('Mul', [input_x, y_real])
-            x_mul_neg_y_imag = graph_builder.emit('Mul', [input_x, neg_y_imag])
-            y_real_div_x = graph_builder.emit('RealDiv', [x_mul_y_real, final_denominator])
-            y_imag_div_x = graph_builder.emit('RealDiv', [x_mul_neg_y_imag, final_denominator])
-            result = graph_builder.emit('Complex', [y_real_div_x, y_imag_div_x])
-        return result

mindspore/_extends/graph_kernel/expanders/complex/mul.py

@@ -1,52 +0,0 @@
-# Copyright 2021-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.
-# ===========================================================================
-"""generate json desc for cmul"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from mindspore._extends.graph_kernel.expanders._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-class CMul(Expander):
-    """CMul expander"""
-
-    def _expand(self, graph_builder):
-        """CMul Implementation"""
-        input_x, input_y = self.inputs
-        if input_x.dtype == input_y.dtype:
-            x_real = graph_builder.emit('CReal', [input_x])
-            y_real = graph_builder.emit('CReal', [input_y])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            x_real_mul_y_real = graph_builder.emit('Mul', [x_real, y_real])
-            x_imag_mul_y_imag = graph_builder.emit('Mul', [x_imag, y_imag])
-            x_real_mul_y_imag = graph_builder.emit('Mul', [x_real, y_imag])
-            x_imag_mul_y_real = graph_builder.emit('Mul', [x_imag, y_real])
-            result_real = graph_builder.emit('Sub', [x_real_mul_y_real, x_imag_mul_y_imag])
-            result_imag = graph_builder.emit('Add', [x_real_mul_y_imag, x_imag_mul_y_real])
-            result = graph_builder.emit('Complex', [result_real, result_imag])
-        elif input_x.dtype == "complex64" or input_x.dtype == "complex128":
-            x_real = graph_builder.emit('CReal', [input_x])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            x_real_mul_y = graph_builder.emit('Mul', [x_real, input_y])
-            x_imag_mul_y = graph_builder.emit('Mul', [x_imag, input_y])
-            result = graph_builder.emit('Complex', [x_real_mul_y, x_imag_mul_y])
-        elif input_y.dtype == "complex64" or input_y.dtype == "complex128":
-            y_real = graph_builder.emit('CReal', [input_y])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            y_real_mul_x = graph_builder.emit('Mul', [y_real, input_x])
-            y_imag_mul_x = graph_builder.emit('Mul', [y_imag, input_x])
-            result = graph_builder.emit('Complex', [y_real_mul_x, y_imag_mul_x])
-
-        return result

mindspore/_extends/graph_kernel/expanders/complex/real_div.py

@@ -1,62 +0,0 @@
-# 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.
-# ===========================================================================
-"""generate json desc for crealdiv"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from mindspore._extends.graph_kernel.expanders._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-class CRealDiv(Expander):
-    """CRealDiv expander"""
-
-    def _expand(self, graph_builder):
-        """CRealDiv Implementation"""
-        input_x, input_y = self.inputs
-        if input_x.dtype == input_y.dtype:
-            x_real = graph_builder.emit('CReal', [input_x])
-            y_real = graph_builder.emit('CReal', [input_y])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            squre_y_real = graph_builder.emit('Mul', [y_real, y_real])
-            squre_y_imag = graph_builder.emit('Mul', [y_imag, y_imag])
-            final_denominator = graph_builder.emit('Add', [squre_y_real, squre_y_imag])
-            x_real_mul_y_real = graph_builder.emit('Mul', [x_real, y_real])
-            x_imag_mul_y_imag = graph_builder.emit('Mul', [x_imag, y_imag])
-            x_real_mul_y_imag = graph_builder.emit('Mul', [x_real, y_imag])
-            x_imag_mul_y_real = graph_builder.emit('Mul', [x_imag, y_real])
-            final_numerator_real = graph_builder.emit('Add', [x_real_mul_y_real, x_imag_mul_y_imag])
-            final_numerator_imag = graph_builder.emit('Sub', [x_imag_mul_y_real, x_real_mul_y_imag])
-            result_real = graph_builder.emit('RealDiv', [final_numerator_real, final_denominator])
-            result_imag = graph_builder.emit('RealDiv', [final_numerator_imag, final_denominator])
-            result = graph_builder.emit('Complex', [result_real, result_imag])
-        elif input_x.dtype == "complex64" or input_x.dtype == "complex128":
-            x_real = graph_builder.emit('CReal', [input_x])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            x_real_div_y = graph_builder.emit('RealDiv', [x_real, input_y])
-            x_imag_div_y = graph_builder.emit('RealDiv', [x_imag, input_y])
-            result = graph_builder.emit('Complex', [x_real_div_y, x_imag_div_y])
-        elif input_y.dtype == "complex64" or input_y.dtype == "complex128":
-            y_real = graph_builder.emit('CReal', [input_y])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            neg_y_imag = graph_builder.emit('Neg', [y_imag])
-            squre_y_real = graph_builder.emit('Mul', [y_real, y_real])
-            squre_y_imag = graph_builder.emit('Mul', [y_imag, y_imag])
-            final_denominator = graph_builder.emit('Add', [squre_y_real, squre_y_imag])
-            x_mul_y_real = graph_builder.emit('Mul', [input_x, y_real])
-            x_mul_neg_y_imag = graph_builder.emit('Mul', [input_x, neg_y_imag])
-            y_real_div_x = graph_builder.emit('RealDiv', [x_mul_y_real, final_denominator])
-            y_imag_div_x = graph_builder.emit('RealDiv', [x_mul_neg_y_imag, final_denominator])
-            result = graph_builder.emit('Complex', [y_real_div_x, y_imag_div_x])
-        return result

mindspore/_extends/graph_kernel/expanders/complex/sub.py

@@ -1,45 +0,0 @@
-# Copyright 2021-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.
-# ===========================================================================
-"""generate json desc for csub"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from mindspore._extends.graph_kernel.expanders._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-class CSub(Expander):
-    """CSub expander"""
-
-    def _expand(self, graph_builder):
-        input_x, input_y = self.inputs
-        if input_x.dtype == input_y.dtype:
-            x_real = graph_builder.emit('CReal', [input_x])
-            y_real = graph_builder.emit('CReal', [input_y])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            result_real = graph_builder.emit('Sub', [x_real, y_real])
-            result_imag = graph_builder.emit('Sub', [x_imag, y_imag])
-            result = graph_builder.emit('Complex', [result_real, result_imag])
-        elif input_x.dtype == "complex64" or input_x.dtype == "complex128":
-            x_real = graph_builder.emit('CReal', [input_x])
-            x_imag = graph_builder.emit('CImag', [input_x])
-            x_real_sub_y = graph_builder.emit('Sub', [x_real, input_y])
-            result = graph_builder.emit('Complex', [x_real_sub_y, x_imag])
-        elif input_y.dtype == "complex64" or input_y.dtype == "complex128":
-            y_real = graph_builder.emit('CReal', [input_y])
-            y_imag = graph_builder.emit('CImag', [input_y])
-            x_sub_y_real = graph_builder.emit('Sub', [input_x, y_real])
-            y_imag = graph_builder.emit('Neg', [y_imag])
-            result = graph_builder.emit('Complex', [x_sub_y_real, y_imag])
-        return result

mindspore/_extends/graph_kernel/expanders/conv2d.py

@@ -1,200 +0,0 @@
-# Copyright 2021-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.
-# ===========================================================================
-"""generate json desc for Conv2D"""
-from mindspore._extends.graph_kernel.model.op_infer import check_format_any, check_nd, conv_had_pad
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from mindspore._extends.graph_kernel.model.model import GraphKernelUnsupportedException as GKException
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-@VLD.add_format(DF.NHWC, DF.NHWC)
-@VLD.check_attrs('format', 'pad_list', 'pad_mode', 'groups', 'group', 'kernel_size', 'stride', 'dilation')
-class Conv2D(Expander):
-    """
-    Conv2D expander
-
-    Currently, only Conv2D that meets several conditions can be expanded, other cases will be skipped.
-    Conditions to expand:
-      inputs are NHWC format and float16.
-      attr groups and group are 1.
-      attr dilation are all 1.
-      N channel of inputs > 16.
-      C channel of inputs > 8.
-      output N*H*W are multiplies of 128.
-    """
-    M_ALIGN = 32
-    N_ALIGN = 32
-    K_ALIGN = 16
-    K_LIMIT = 800
-    MNK_LIMIT = 3 * (10 ** 10)
-    N0_CHANNEL_ALIGN = 32
-    N1_CHANNEL_ALIGN = 32
-    C_CHANNEL_ALIGN = 16
-    OUT_NHW_ALIGN = 128
-
-    def __init__(self, expand_info):
-        super().__init__(expand_info)
-        self.dst_type = self.outputs[0]['data_type']
-        self.dst_format = self.outputs[0]['format']
-        self.has_pad = False
-        self.can_optimize_to_matmul = False
-        self.shape_0_pad = self.inputs[0]['shape']
-        self.shape_1_pad = self.inputs[1]['shape']
-        self.m = 0
-        self.n = 0
-        self.k = 0
-
-    def _optimize_to_matmul(self):
-        stride = self.attrs['stride']
-        dilation = self.attrs['dilation']
-        _, h, w, _ = self.inputs[1]['shape']
-        if h == 1 and w == 1 and stride == [1, 1, 1, 1] and dilation == [1, 1, 1, 1] and \
-                self.m % self.M_ALIGN == 0 and self.n % self.N_ALIGN == 0 and self.k % self.K_ALIGN == 0:
-            return True
-        return False
-
-    def _common_check(self):
-        """common check for inputs and attrs"""
-        type_0 = self.inputs[0]['data_type']
-        type_1 = self.inputs[1]['data_type']
-        if type_0 != "float16" or type_1 != "float16":
-            raise GKException("For 'Conv2D', inputs data type should be both float16, but got {} and {}"
-                              .format(type_0, type_1))
-
-        formats = [self.inputs[0]['format'], self.inputs[1]['format'], self.attrs['format']]
-        check_format_any(formats, DF.NHWC)
-
-        groups = self.attrs['groups']
-        group = self.attrs['group']
-        if groups != 1 or group != 1:
-            raise GKException("For 'Conv2D', value of attr 'groups' and 'group' should be both 1, but got {} and {}."
-                              .format(groups, group))
-
-        dilation = self.attrs['dilation']
-        check_nd(dilation, 4)
-        if dilation != [1, 1, 1, 1]:
-            raise GKException("For 'Conv2D', value of attr 'dilation' should be [1, 1, 1, 1], but got {}"
-                              .format(dilation))
-
-    def _check(self):
-        self._common_check()
-
-        pad_list = self.attrs['pad_list']
-        check_nd(pad_list, 4)
-        self.has_pad = conv_had_pad(pad_list, self.attrs['pad_mode'])
-
-        shape_0 = self.inputs[0]['shape']
-        shape_1 = self.inputs[1]['shape']
-        stride = self.attrs['stride']
-        check_nd(shape_0, 4)
-        check_nd(shape_1, 4)
-        check_nd(stride, 4)
-        n0, h0, w0, c0 = shape_0
-        n1, h1, w1, c1 = shape_1
-        if (n0 % self.N0_CHANNEL_ALIGN) != 0:
-            raise GKException("For 'Conv2D', N channel of first input should be multiples of {}, but got {}"
-                              .format(self.N0_CHANNEL_ALIGN, n0))
-        if (n1 % self.N1_CHANNEL_ALIGN) != 0:
-            raise GKException("For 'Conv2D', N channel of second input should be multiples of {}, but got {}"
-                              .format(self.N1_CHANNEL_ALIGN, n1))
-        if c0 != c1 or (c0 % self.C_CHANNEL_ALIGN) != 0:
-            raise GKException("For 'Conv2D', C channel of inputs should be same and also be multiples of {}, but got "
-                              "{} and {}".format(self.C_CHANNEL_ALIGN, c0, c1))
-        # n0 pad
-        n0 = ((n0 + self.N0_CHANNEL_ALIGN - 1) //
-              self.N0_CHANNEL_ALIGN) * self.N0_CHANNEL_ALIGN
-        # h0, w0 pad
-        if self.has_pad:
-            h0 = h0 + pad_list[0] + pad_list[1]
-            w0 = w0 + pad_list[2] + pad_list[3]
-        # c0, c1 pad
-        c0 = ((c0 + self.C_CHANNEL_ALIGN - 1) // self.C_CHANNEL_ALIGN) * self.C_CHANNEL_ALIGN
-        c1 = c0
-        # n1 pad
-        n1 = ((n1 + self.N1_CHANNEL_ALIGN - 1) //
-              self.N1_CHANNEL_ALIGN) * self.N1_CHANNEL_ALIGN
-
-        # check if can optimize to matmul
-        self.m, self.n, self.k = n0 * h0 * w0, n1, c1
-        self.can_optimize_to_matmul = self._optimize_to_matmul()
-
-        # requirements
-        if self.can_optimize_to_matmul:
-            if self.k > self.K_LIMIT:
-                raise GKException("For 'Conv2D', if transformed to 'MatMul', C0 should not be larger than {}, but got "
-                                  "{}".format(self.K_LIMIT, self.k))
-            if self.m * self.n * self.k >= self.MNK_LIMIT:
-                raise GKException("For 'Conv2D', if transformed to 'MatMul', The total size should not be larger than "
-                                  "{}, but got {}".format(self.MNK_LIMIT, self.m * self.n * self.k))
-        else:
-            out_h, out_w = (h0 - h1) // stride[-2] + 1, (w0 - w1) // stride[-1] + 1
-            if ((n0 * out_h * out_w) % self.OUT_NHW_ALIGN) != 0:
-                raise GKException("For 'Conv2D', N({}) * H({}) * W({}) of output should be multiplies of {}"
-                                  .format(n0, out_h, out_w, self.OUT_NHW_ALIGN))
-            if stride != [1, 1, 2, 2]:
-                raise GKException("For 'Conv2D', value of attr 'stride' should be [1, 1, 2, 2], but got {}"
-                                  .format(stride))
-
-        self.shape_0_pad = [n0, h0, w0, c0]
-        self.shape_1_pad = [n1, h1, w1, c1]
-
-    def _expand(self, graph_builder):
-        input_0 = self.inputs[0]
-        input_1 = self.inputs[1]
-        n0, _, _, c0 = input_0.shape
-        n1, _, _, c1 = input_1.shape
-        n0_p, h0_p, w0_p, c0_p = self.shape_0_pad
-        n1_p, _, _, c1_p = self.shape_1_pad
-
-        pad_value = 0
-        # input0 pad
-        input_0_pad_before = [0, 0, 0, 0]
-        input_0_pad_after = [0, 0, 0, 0]
-        if self.has_pad:
-            pad_list = self.attrs['pad_list']
-            input_0_pad_before = [0, pad_list[0], pad_list[2], 0]
-            input_0_pad_after = [0, pad_list[1], pad_list[3], 0]
-        input_0_pad_after[0] = n0_p - n0
-        input_0_pad_after[3] = c0_p - c0
-        if input_0_pad_before != [0, 0, 0, 0] or input_0_pad_after != [0, 0, 0, 0]:
-            input_0 = graph_builder.emit('PadAkg', [input_0], attrs={'head': input_0_pad_before,
-                                                                     'tail': input_0_pad_after,
-                                                                     'pad_val': pad_value})
-        # input1 pad
-        input_1_pad_after = [n1_p - n1, 0, 0, c1_p - c1]
-        if input_1_pad_after != [0, 0, 0, 0]:
-            input_1 = graph_builder.emit('PadAkg', [input_1], attrs={'head': [0, 0, 0, 0],
-                                                                     'tail': input_1_pad_after,
-                                                                     'pad_val': pad_value})
-        if self.can_optimize_to_matmul:
-            a = graph_builder.emit('Reshape', [input_0], attrs={'shape': [self.m, self.k]})
-            b = graph_builder.emit('Reshape', [input_1], attrs={'shape': [self.n, self.k]})
-            c = graph_builder.emit('MatMul', [a, b], attrs={'transpose_a': False,
-                                                            'transpose_b': True,
-                                                            'dst_type': self.dst_type})
-            result = graph_builder.emit('Reshape', [c], attrs={'shape': [n0_p, h0_p, w0_p, n1_p],
-                                                               'format': self.dst_format})
-        else:
-            attrs = self.attrs
-            attrs['pad_list'] = [0, 0, 0, 0]
-            attrs['dst_type'] = self.dst_type
-            result = graph_builder.emit('Conv2D', [input_0, input_1], attrs=attrs)
-        # unpad
-        unpad_after = [input_0_pad_after[0], 0, 0, input_1_pad_after[0]]
-        if unpad_after != [0, 0, 0, 0]:
-            result = graph_builder.emit('UnPadAkg', [result], attrs={'tail': unpad_after})
-
-        return result