mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/_extends/graph_kernel/expanders/fused_adam_weight_decay.py

@@ -1,47 +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 fused_adam_weight_decay"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-class FusedAdamWeightDecay(Expander):
-    """FusedAdamWeightDecay expander"""
-
-    def _expand(self, graph_builder):
-        beta_1, one_sub_beta_1, beta_2, one_sub_beta_2, eps, lr, param, m, v, gradient, weight_decay = self.inputs
-
-        # compute result
-        beta_1_mul_m = graph_builder.emit('Mul', [beta_1, m])
-        one_sub_beta_1_mul_grad = graph_builder.emit('Mul', [one_sub_beta_1, gradient])
-        next_m = graph_builder.emit('Add', [beta_1_mul_m, one_sub_beta_1_mul_grad])
-        beta_2_mul_v = graph_builder.emit('Mul', [beta_2, v])
-        grad_square = graph_builder.emit('Mul', [gradient, gradient])
-        one_sub_beta_2_mul_grad_square = graph_builder.emit('Mul', [one_sub_beta_2, grad_square])
-        next_v = graph_builder.emit('Add', [beta_2_mul_v, one_sub_beta_2_mul_grad_square])
-        sqrt_next_v = graph_builder.emit('Sqrt', [next_v])
-        sqrt_next_v_add_eps = graph_builder.emit('Add', [sqrt_next_v, eps])
-        update = graph_builder.emit('RealDiv', [next_m, sqrt_next_v_add_eps])
-        param_with_weight_decay = graph_builder.emit('Mul', [weight_decay, param])
-        update = graph_builder.emit('Add', [update, param_with_weight_decay])
-        update_with_lr = graph_builder.emit('Mul', [lr, update])
-        next_para = graph_builder.emit('Sub', [param, update_with_lr])
-
-        para_result = graph_builder.emit(
-            'InplaceAssign', [param, next_para, next_para], attrs={'fake_output': True})
-        para_result = graph_builder.emit('InplaceAssign', [m, next_m, para_result], attrs={'fake_output': True})
-        para_result = graph_builder.emit('InplaceAssign', [v, next_v, para_result], attrs={'fake_output': True})
-
-        return para_result

mindspore/_extends/graph_kernel/expanders/fused_mul_add.py

@@ -1,28 +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 FusedMulAdd"""
-from ._utils import Expander
-
-
-class FusedMulAdd(Expander):
-    """FusedMulAdd expander"""
-
-    def _expand(self, graph_builder):
-        input_x, input_y, input_z = self.inputs
-
-        mul_res = graph_builder.emit('Mul', [input_x, input_y])
-        result = graph_builder.emit('Add', [mul_res, input_z])
-
-        return result

mindspore/_extends/graph_kernel/expanders/gelu_grad.py

@@ -1,70 +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 gelugrad"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-class GeLUGrad(Expander):
-    """GeLUGrad expander"""
-    CSVALUE = 0.044715
-    CSVALUE_SQRT_TWO_DIV_PI = 0.7978845608028564  # np.sqrt(2/np.pi)
-    CSVALUE_TRI = 0.134141  # CSVALUE * 3
-
-    def _expand(self, graph_builder):
-        # cal formula are:
-        # gelu_grad of dy and x is dy * y'
-        # y' is 0.5 * (1.0 + tanh(tanh_para)) + 0.5 * x * (1.0 - tanh(tanh_para) * tanh(para)) * mul_right
-        # tanh_para is 'sqrt(2.0 / pi) * (x + 0.044715 * x * x * x)'
-        # mul_right is 'sqrt(2.0 / pi) * (1 + 3 * 0.044715 * x * x)'
-
-        input_dy, input_x, _ = self.inputs
-
-        # create some const var
-        const_csvalue = graph_builder.value(input_dy.dtype, self.CSVALUE)
-        const_csvalue_sqrt_two_div_pi = graph_builder.value(input_dy.dtype, self.CSVALUE_SQRT_TWO_DIV_PI)
-        const_csvalue_tri = graph_builder.value(input_dy.dtype, self.CSVALUE_TRI)
-        const_one = graph_builder.value(input_dy.dtype, 1)
-        const_half = graph_builder.value(input_dy.dtype, 0.5)
-
-        # cal mul_right
-        mul_double = graph_builder.emit('Mul', [input_x, input_x])
-        mul_double_mul_tri = graph_builder.emit('Mul', [const_csvalue_tri, mul_double])
-        mul_add_one = graph_builder.emit('Add', [const_one, mul_double_mul_tri])
-        mul_right = graph_builder.emit('Mul', [const_csvalue_sqrt_two_div_pi, mul_add_one])
-
-        # cal tanh_para
-        mul_triple = graph_builder.emit('Mul', [input_x, mul_double])
-        mul_triple_mul_csvalue = graph_builder.emit('Mul', [const_csvalue, mul_triple])
-        mul_add_x = graph_builder.emit('Add', [input_x, mul_triple_mul_csvalue])
-        tanh_para = graph_builder.emit('Mul', [const_csvalue_sqrt_two_div_pi, mul_add_x])
-
-        # cal 0.5 * (1.0 + tanh(tahn_para))
-        tanh_res = graph_builder.emit('Tanh', [tanh_para])
-        tanh_res_add_one = graph_builder.emit('Add', [const_one, tanh_res])
-        half_mul_tanh_res_add_one = graph_builder.emit('Mul', [const_half, tanh_res_add_one])
-
-        # cal 0.5 * x * (1.0 - tanh(tanh_para) * tanh(tanh_para)) * mul_right
-        tan_res_double = graph_builder.emit('Mul', [tanh_res, tanh_res])
-        one_sub_tan_res_double = graph_builder.emit('Sub', [const_one, tan_res_double])
-        half_mul_x = graph_builder.emit('Mul', [const_half, input_x])
-        mul_tmp = graph_builder.emit('Mul', [half_mul_x, one_sub_tan_res_double])
-        mul_final = graph_builder.emit('Mul', [mul_tmp, mul_right])
-
-        # cal result
-        result_tmp = graph_builder.emit('Add', [half_mul_tanh_res_add_one, mul_final])
-        result = graph_builder.emit('Mul', [input_dy, result_tmp])
-
-        return result

mindspore/_extends/graph_kernel/expanders/gkdropout.py

@@ -1,40 +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 GkDropout"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-@VLD.check_attrs('keep_prob')
-class GkDropout(Expander):
-    """GkDropout expander"""
-
-    def _expand(self, graph_builder):
-        input_x, input_mask = self.inputs
-        keep_prob = self.attrs['keep_prob']
-
-        r_keep_prob = graph_builder.value(input_x.dtype, 1.0 / keep_prob)
-        keep_prob = graph_builder.value(input_x.dtype, keep_prob)
-
-        if input_mask.dtype != input_x.dtype:
-            input_mask = graph_builder.emit('Cast', [input_mask], attrs={'dst_type': input_x.dtype})
-        mask = graph_builder.emit('LessEqual', [input_mask, keep_prob])  # output is bool type
-        mask = graph_builder.emit('Cast', [mask], attrs={'dst_type': input_x.dtype})
-
-        # compute result
-        result = graph_builder.emit('Mul', [r_keep_prob, input_x])
-        result = graph_builder.emit('Mul', [result, mask])
-
-        return result, mask

mindspore/_extends/graph_kernel/expanders/identity.py

@@ -1,25 +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 Identity"""
-from ._utils import Expander
-
-
-class Identity(Expander):
-    """Identity expander"""
-
-    def _expand(self, graph_builder):
-        input_x = self.inputs[0]
-        result = graph_builder.emit('Reshape', [input_x], attrs={'shape': input_x.shape})
-        return result

mindspore/_extends/graph_kernel/expanders/layernorm.py

@@ -1,93 +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.
-# ===========================================================================
-"""generate json desc for LayerNorm"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from ._utils import Expander, ExpanderInfoValidator as VLD
-from ._utils import infer_shape_from_fractalnz, get_reduced_ori_shape, to_frac_z_axis
-
-
-@VLD.add_format(DF.FRAC_NZ, DF.DEFAULT, DF.DEFAULT)
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT, DF.DEFAULT)
-@VLD.check_attrs('begin_norm_axis', 'begin_params_axis', 'epsilon')
-class LayerNorm(Expander):
-    """LayerNorm expander"""
-
-    def _expand(self, graph_builder):
-        input_x, input_gamma, input_beta = self.inputs
-        processor = self.processor
-        begin_norm_axis = self.attrs['begin_norm_axis']
-        epsilon = self.attrs['epsilon']
-
-        ori_dtype = input_x.dtype
-        if processor == 'aicore' and ori_dtype == 'float16':
-            input_x = graph_builder.emit('Cast', [input_x], attrs={'dst_type': 'float32'})
-            input_gamma = graph_builder.emit('Cast', [input_gamma], attrs={'dst_type': 'float32'})
-            input_beta = graph_builder.emit('Cast', [input_beta], attrs={'dst_type': 'float32'})
-
-        ori_shape_x = input_x.shape
-        if input_x.data_format == DF.FRAC_NZ:
-            ori_shape_x = infer_shape_from_fractalnz(input_x.shape)
-
-        # Calculate the scaling ratio of the average
-        if begin_norm_axis < 0:
-            begin_norm_axis += len(ori_shape_x)
-
-        reduce_axis = ()
-        for i, _ in enumerate(ori_shape_x):
-            if i > begin_norm_axis or i == begin_norm_axis:
-                reduce_axis = reduce_axis + (i,)
-
-        reduce_elts = 1.0
-        for i in reduce_axis:
-            reduce_elts *= ori_shape_x[i]
-        # after reduced
-        ori_reduced_shape_x = get_reduced_ori_shape(ori_shape_x, reduce_axis)
-
-        axis = reduce_axis
-        if input_x.data_format == DF.FRAC_NZ:
-            axis = to_frac_z_axis(ori_shape_x, reduce_axis)
-
-        mean_cof_v = graph_builder.value(input_x.dtype, 1.0 / reduce_elts)
-
-        # Calculate mean
-        mean_red = graph_builder.emit('ReduceSum', [input_x], attrs={'reduce_axis': axis, 'keep_dims': True})
-        mean = graph_builder.emit('Mul', [mean_red, mean_cof_v])
-        if input_x.data_format == DF.FRAC_NZ:
-            mean = graph_builder.emit('Reshape', [mean], attrs={'shape': ori_reduced_shape_x})
-
-        # Calculate variance
-        variance_sub = graph_builder.emit('Sub', [input_x, mean])
-        variance_mul = graph_builder.emit('Mul', [variance_sub, variance_sub])
-        variance_red = graph_builder.emit('ReduceSum', [variance_mul], attrs={'reduce_axis': axis, 'keep_dims': True})
-        variance = graph_builder.emit('Mul', [variance_red, mean_cof_v])
-        if input_x.data_format == DF.FRAC_NZ:
-            variance = graph_builder.emit('Reshape', [variance], attrs={'shape': ori_reduced_shape_x})
-
-        # Calculate normalize
-        normalize_sub = graph_builder.emit('Sub', [input_x, mean])
-        epsilon_v = graph_builder.value(input_x.dtype, epsilon)
-        normalize_add = graph_builder.emit('Add', [variance, epsilon_v])
-        normlize_rsqrt = graph_builder.emit('Rsqrt', [normalize_add])
-        normalize_mul = graph_builder.emit('Mul', [normalize_sub, normlize_rsqrt])
-
-        # Calculate scale and translate
-        scale_mul = graph_builder.emit('Mul', [normalize_mul, input_gamma])
-        res = graph_builder.emit('Add', [scale_mul, input_beta])
-
-        if processor == 'aicore' and ori_dtype == 'float16':
-            res = graph_builder.emit('Cast', [res], attrs={'dst_type': 'float16'})
-            mean = graph_builder.emit('Cast', [mean], attrs={'dst_type': 'float16'})
-            variance = graph_builder.emit('Cast', [variance], attrs={'dst_type': 'float16'})
-        return res, mean, variance

mindspore/_extends/graph_kernel/expanders/layernorm_grad.py

@@ -1,113 +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 LayerNormGrad"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT, DF.DEFAULT)
-@VLD.check_attrs('begin_norm_axis', 'begin_params_axis')
-class LayerNormGrad(Expander):
-    """LayerNormGrad expander"""
-
-    def _expand(self, graph_builder):
-        x, dy, variance, mean, gamma = self.inputs
-        processor = self.processor
-        begin_norm_axis = self.attrs['begin_norm_axis']
-        begin_params_axis = self.attrs['begin_params_axis']
-        epsilon = self.attrs['epsilon'] if 'epsilon' in self.attrs else 1e-12
-
-        ori_dtype = x.dtype
-        if processor == 'aicore' and ori_dtype == 'float16':
-            x = graph_builder.emit('Cast', [x], attrs={'dst_type': 'float32'})
-            dy = graph_builder.emit('Cast', [dy], attrs={'dst_type': 'float32'})
-            variance = graph_builder.emit('Cast', [variance], attrs={'dst_type': 'float32'})
-            mean = graph_builder.emit('Cast', [mean], attrs={'dst_type': 'float32'})
-            gamma = graph_builder.emit('Cast', [gamma], attrs={'dst_type': 'float32'})
-
-        if begin_norm_axis < 0:
-            begin_norm_axis += len(x.shape)
-        if begin_params_axis < 0:
-            begin_params_axis += len(x.shape)
-
-        norm_axis = tuple(range(begin_norm_axis, len(x.shape)))
-        param_axis = tuple(range(0, begin_params_axis))
-
-        reduce_size = 1.0
-        for i in norm_axis:
-            reduce_size *= x.shape[i]
-
-        # set some constant val.
-        eps = graph_builder.value(x.dtype, epsilon)
-        const_neg_half = graph_builder.value(x.dtype, -0.5)
-        const_neg_two = graph_builder.value(x.dtype, -2.0)
-        const_two = graph_builder.value(x.dtype, 2.0)
-        const_neg_one = graph_builder.value(x.dtype, -1.0)
-        mean_cof = graph_builder.value(x.dtype, (1.0 / reduce_size))
-
-        # cal dg db
-        var_eps = graph_builder.emit('Add', [variance, eps])
-        var_eps_log = graph_builder.emit('Log', [var_eps])
-        var_eps_mul = graph_builder.emit('Mul', [var_eps_log, const_neg_half])
-        rsqrt_var_eps = graph_builder.emit('Exp', [var_eps_mul])
-
-        x_sub_mean = graph_builder.emit('Sub', [x, mean])
-
-        x_sub_mean_mul_rsqrt_var_eps = graph_builder.emit('Mul', [rsqrt_var_eps, x_sub_mean])
-        dg_mul = graph_builder.emit('Mul', [dy, x_sub_mean_mul_rsqrt_var_eps])
-        dg = graph_builder.emit('ReduceSum', [dg_mul], attrs={'reduce_axis': param_axis, 'keep_dims': False})
-        db = graph_builder.emit('ReduceSum', [dy], attrs={'reduce_axis': param_axis, 'keep_dims': False})
-
-        # pd_var
-        tmp_var_eps = graph_builder.emit('Mul', [rsqrt_var_eps, rsqrt_var_eps])
-        r_tmp_var_eps = graph_builder.emit('Mul', [rsqrt_var_eps, tmp_var_eps])
-
-        dy_mul_gamma = graph_builder.emit('Mul', [dy, gamma])
-        tmp_mul = graph_builder.emit('Mul', [dy_mul_gamma, x_sub_mean])
-        padvar_mul1 = graph_builder.emit('ReduceSum', [tmp_mul], attrs={'reduce_axis': norm_axis, 'keep_dims': True})
-        padvar_mul3 = graph_builder.emit('Mul', [padvar_mul1, r_tmp_var_eps])
-        pd_var = graph_builder.emit('Mul', [padvar_mul3, const_neg_half])
-
-        # pd_mean
-        pdmean1_sum = graph_builder.emit('ReduceSum', [dy_mul_gamma],
-                                         attrs={'reduce_axis': norm_axis, 'keep_dims': True})
-        neg_rsqrt_var_eps = graph_builder.emit('Mul', [rsqrt_var_eps, const_neg_one])
-        pd_mean_1 = graph_builder.emit('Mul', [neg_rsqrt_var_eps, pdmean1_sum])
-
-        pdmean2_mul1 = graph_builder.emit('Mul', [const_neg_two, x_sub_mean])
-        pdmean2_sum = graph_builder.emit('ReduceSum', [pdmean2_mul1],
-                                         attrs={'reduce_axis': norm_axis, 'keep_dims': True})
-        pdmean2_mul3 = graph_builder.emit('Mul', [pdmean2_sum, mean_cof])
-        pd_mean_2 = graph_builder.emit('Mul', [pdmean2_mul3, pd_var])
-
-        pd_mean = graph_builder.emit('Add', [pd_mean_1, pd_mean_2])
-
-        # cal dx
-        pd_x_1 = graph_builder.emit('Mul', [dy_mul_gamma, rsqrt_var_eps])
-
-        pdx2_mul = graph_builder.emit('Mul', [pd_var, x_sub_mean])
-        pdx2_mul_two = graph_builder.emit('Mul', [pdx2_mul, const_two])
-        pd_x_2 = graph_builder.emit('Mul', [pdx2_mul_two, mean_cof])
-
-        pd_x_3 = graph_builder.emit('Mul', [pd_mean, mean_cof])
-
-        dx_tmp = graph_builder.emit('Add', [pd_x_1, pd_x_2])
-        dx = graph_builder.emit('Add', [dx_tmp, pd_x_3])
-
-        if processor == 'aicore' and ori_dtype == 'float16':
-            dx = graph_builder.emit('Cast', [dx], attrs={'dst_type': 'float16'})
-            dg = graph_builder.emit('Cast', [dg], attrs={'dst_type': 'float16'})
-            db = graph_builder.emit('Cast', [db], attrs={'dst_type': 'float16'})
-        return dx, dg, db

mindspore/_extends/graph_kernel/expanders/logsoftmax.py

@@ -1,46 +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 LogSoftmax"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT)
-@VLD.check_attrs('axis')
-class LogSoftmax(Expander):
-    """LogSoftmax expander"""
-
-    def _expand(self, graph_builder):
-        input_x = self.inputs[0]
-        axis = self.attrs['axis']
-        processor = self.processor
-
-        if isinstance(axis, int):
-            axis = (axis,)
-
-        ori_dtype = input_x.dtype
-        if ori_dtype != "float16" and processor == "aicore":
-            input_x_f16 = graph_builder.emit('Cast', [input_x], attrs={'dst_type': 'float16'})
-            max_x_f16 = graph_builder.emit('ReduceMax', [input_x_f16], attrs={'reduce_axis': axis, 'keep_dims': True})
-            max_x = graph_builder.emit('Cast', [max_x_f16], attrs={'dst_type': ori_dtype})
-        else:
-            max_x = graph_builder.emit('ReduceMax', [input_x], attrs={'reduce_axis': axis, 'keep_dims': True})
-        data_sub = graph_builder.emit('Sub', [input_x, max_x])
-        data_exp = graph_builder.emit('Exp', [data_sub])
-        data_expsum = graph_builder.emit('ReduceSum', [data_exp], attrs={'reduce_axis': axis, 'keep_dims': True})
-        log_expsum = graph_builder.emit('Log', [data_expsum])
-        result = graph_builder.emit('Sub', [data_sub, log_expsum])
-
-        return result

mindspore/_extends/graph_kernel/expanders/logsoftmax_grad.py

@@ -1,36 +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 LogSoftmaxGrad"""
-from mindspore._extends.graph_kernel.model.model import DataFormat as DF
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.add_format(DF.DEFAULT, DF.DEFAULT)
-@VLD.check_attrs('axis')
-class LogSoftmaxGrad(Expander):
-    """LogSoftmaxGrad expander"""
-
-    def _expand(self, graph_builder):
-        input_logits, input_dy = self.inputs
-        axis = self.attrs['axis']
-        if isinstance(axis, int):
-            axis = (axis,)
-
-        softmax = graph_builder.emit('Exp', [input_logits])
-        dy_sum = graph_builder.emit('ReduceSum', [input_dy], attrs={'reduce_axis': axis, 'keep_dims': True})
-        mul_result = graph_builder.emit('Mul', [softmax, dy_sum])
-        result = graph_builder.emit('Sub', [input_dy, mul_result])
-
-        return result

mindspore/_extends/graph_kernel/expanders/matmul.py

@@ -1,80 +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 BatchMatMul and MatMul"""
-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.check_attrs('transpose_a', 'transpose_b', 'left_format', 'right_format')
-class MatMul(Expander):
-    """
-    MatMul expander
-    """
-
-    def __init__(self, expand_info):
-        super(MatMul, self).__init__(expand_info)
-        self.shape_a = self.inputs[0]['shape']
-        self.shape_b = self.inputs[1]['shape']
-        self.transpose_a = False
-        self.transpose_b = False
-        self.left_format = ""
-        self.right_format = ""
-
-    def _optimize_to_mul(self):
-        """check if matmul can be replace by mul"""
-        if self.processor != 'aicore' or self.left_format != DF.DEFAULT or self.right_format != DF.DEFAULT:
-            return False
-        k_a = self.shape_a[-2] if self.transpose_a else self.shape_a[-1]
-        k_b = self.shape_b[-1] if self.transpose_b else self.shape_b[-2]
-        if k_a != 1 or k_b != 1:
-            return False
-        return True
-
-    def _check(self):
-        input_num = len(self.inputs)
-        if input_num < 2:
-            raise GKException("For 'MatMul', inputs number should bigger than 1, but got {}.".format(input_num))
-
-    def _expand(self, graph_builder):
-        self.transpose_a = self.attrs['transpose_a']
-        self.transpose_b = self.attrs['transpose_b']
-        self.left_format = self.attrs['left_format']
-        self.right_format = self.attrs['right_format']
-
-        def transpose(shape):
-            trans_shape = list(shape)
-            trans_shape[-2] = shape[-1]
-            trans_shape[-1] = shape[-2]
-            return trans_shape
-        if not self._optimize_to_mul():
-            raise GKException("MatMul/BatchMatMul do not need to be replaced by Mul")
-        # Matmul is replaced by Mul([b m k], [b k n]) when k==1
-        input_a = self.inputs[0]
-        input_b = self.inputs[1]
-        if self.transpose_a:
-            shape_a_trans = transpose(self.shape_a)
-            input_a = graph_builder.emit('Reshape', [input_a], attrs={'shape': shape_a_trans})
-        if self.transpose_b:
-            shape_b_trans = transpose(self.shape_b)
-            input_b = graph_builder.emit('Reshape', [input_b], attrs={'shape': shape_b_trans})
-        result = graph_builder.emit('Mul', [input_a, input_b])
-        if 'dst_type' in self.attrs and self.inputs[0].dtype != self.attrs['dst_type']:
-            result = graph_builder.emit('Cast', [result], attrs={'dst_type': self.attrs['dst_type']})
-        return result
-
-
-class BatchMatMul(MatMul):
-    """BatchMatMul expander"""

mindspore/_extends/graph_kernel/expanders/maximum_grad.py

@@ -1,59 +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.
-# ===========================================================================
-"""generate json desc for maximum_grad"""
-from mindspore._extends.graph_kernel.model.model import GraphKernelUnsupportedException as GKException
-from ._utils import Expander, ExpanderInfoValidator as VLD
-from .minimum_grad import MinimumGrad
-
-
-@VLD.check_all_formats_same
-class MaximumGrad(Expander):
-    """MaximumGrad expander"""
-
-    def _check(self):
-        if not self.attrs.get('grad_x', True) and not self.attrs.get('grad_y', True):
-            raise GKException("For 'MaximumGrad', value of attr 'grad_x' and 'grad_y' should be False, but got {} and "
-                              "{}".format(self.attrs.get('grad_x'), self.attrs.get('grad_y')))
-        return super()._check()
-
-    def _expand(self, graph_builder):
-        input_x, input_y, input_dout = self.inputs
-        ge_result = graph_builder.emit('GreaterEqual', [input_x, input_y])
-        ge_result = graph_builder.emit('Cast', [ge_result], attrs={'dst_type': input_x.dtype})
-        dx = graph_builder.emit('Mul', [ge_result, input_dout])
-        dy = graph_builder.emit('Sub', [input_dout, dx])
-
-        reduce_axis_x = MinimumGrad.get_reduce_axis(input_x.shape, dx.shape)
-        reduce_axis_y = MinimumGrad.get_reduce_axis(input_y.shape, dy.shape)
-        if reduce_axis_x:
-            dx_reduce = graph_builder.emit('ReduceSum', [dx], attrs={'reduce_axis': reduce_axis_x, 'keep_dims': False})
-            if dx_reduce.shape != input_x.shape:
-                dx_out = graph_builder.emit('Reshape', [dx_reduce], attrs={'shape': input_x.shape})
-            else:
-                dx_out = dx_reduce
-        else:
-            dx_out = dx
-
-        if reduce_axis_y:
-            dy_reduce = graph_builder.emit('ReduceSum', [dy], attrs={'reduce_axis': reduce_axis_y, 'keep_dims': False})
-            if dy_reduce.shape != input_y.shape:
-                dy_out = graph_builder.emit('Reshape', [dy_reduce], attrs={'shape': input_y.shape})
-            else:
-                dy_out = dy_reduce
-        else:
-            dy_out = dy
-
-        # output two results, regardless of grad_x and grad_y
-        return dx_out, dy_out