mindspore 2.1.0__cp38-none-any.whl → 2.2.10__cp38-none-any.whl

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

mindspore/_extends/graph_kernel/expanders/dropout_grad.py

@@ -1,30 +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 DropoutGrad"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-@VLD.check_attrs('keep_prob')
-class DropoutGrad(Expander):
-    """DropoutGrad expander"""
-
-    def _expand(self, graph_builder):
-        input_dy, input_mask = self.inputs
-        keep_prob = self.attrs['keep_prob']
-        r_keep_prob = graph_builder.value(input_dy.dtype, 1.0 / keep_prob)
-        result = graph_builder.emit('Mul', [input_dy, r_keep_prob])
-        result = graph_builder.emit('Mul', [result, input_mask])
-        return result

mindspore/_extends/graph_kernel/expanders/equal_count.py

@@ -1,50 +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 equal_count"""
-from mindspore._extends.graph_kernel.model.model import GraphKernelUnsupportedException as GKException
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-class EqualCount(Expander):
-    """EqualCount expander"""
-
-    def __init__(self, expand_info):
-        super().__init__(expand_info)
-        self.shape_x = self.inputs[0]['shape']
-        self.shape_y = self.inputs[1]['shape']
-        self.dtype_x = self.inputs[0]['data_type']
-        self.dtype_y = self.inputs[1]['data_type']
-
-    def _check(self):
-        if self.shape_x != self.shape_y:
-            raise GKException("For 'EqualCount', the inputs shape should be same, but got {} and {}"
-                              .format(self.shape_x, self.shape_y))
-        if self.dtype_x != self.dtype_y:
-            raise GKException("For 'EqualCount', the inputs data type should be same, but got {} and {}"
-                              .format(self.dtype_x, self.dtype_y))
-
-    def _expand(self, graph_builder):
-        input_x = self.inputs[0]
-        input_y = self.inputs[1]
-
-        eql_val = graph_builder.emit('Equal', [input_x, input_y])
-        cast_val = graph_builder.emit('Cast', [eql_val], attrs={'dst_type': 'float32'})
-        axis = list(range(len(input_x.shape)))
-        result = graph_builder.emit('ReduceSum', [cast_val], attrs={'reduce_axis': axis, 'keep_dims': False})
-
-        if result.dtype != input_x.dtype:
-            result = graph_builder.emit('Cast', [result], attrs={'dst_type': input_x.dtype})
-        return result

mindspore/_extends/graph_kernel/expanders/erfc.py

@@ -1,35 +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 erfc"""
-from ._utils import Expander
-
-
-class Erfc(Expander):
-    """Erfc expander"""
-
-    def _expand(self, graph_builder):
-        input_x = self.inputs[0]
-        result = None
-        if input_x.dtype == "float16":
-            const_one = graph_builder.value("float32", 1)
-            input_x = graph_builder.emit('Cast', [input_x], attrs={'dst_type': "float32"})
-            erf_result = graph_builder.emit('Erf', [input_x])
-            result = graph_builder.emit('Sub', [const_one, erf_result])
-            result = graph_builder.emit('Cast', [result], attrs={'dst_type': "float16"})
-            return result
-        const_one = graph_builder.value(input_x.dtype, 1)
-        erf_result = graph_builder.emit('Erf', [input_x])
-        result = graph_builder.emit('Sub', [const_one, erf_result])
-        return result

mindspore/_extends/graph_kernel/expanders/expand_dims.py

@@ -1,50 +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 expand_dims"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_attrs('axis')
-class ExpandDims(Expander):
-    """ExpandDims expander"""
-
-    def _expand(self, graph_builder):
-        input_x = self.inputs[0]
-        shape = self.infer_shape(input_x.shape, self.attrs['axis'])
-        result = graph_builder.emit('Reshape', [input_x], attrs={'shape': shape})
-
-        return result
-
-    @staticmethod
-    def infer_shape(shape, axis):
-        """infer shape for expand_dims"""
-        def insert_axis(shape, axis):
-            if not isinstance(axis, int) or axis > len(shape) or axis < -len(shape) - 1:
-                raise ValueError("For 'ExpandDims', value of attr 'axis' should be of type int and in the range [{}, "
-                                 "{}], but got {} with type {}".format(-len(shape) - 1, len(shape), axis, type(axis)))
-            if axis >= 0:
-                shape.insert(axis, 1)
-            else:
-                shape.insert(axis + len(shape) + 1, 1)
-            return shape
-        out_shape = shape[:]
-        if isinstance(axis, int):
-            return insert_axis(out_shape, axis)
-        if isinstance(axis, (list, tuple)):
-            for i in axis:
-                out_shape = insert_axis(out_shape, i)
-            return out_shape
-        raise ValueError("For 'ExpandDims', type of attr 'axis' should be one of ['int', 'list', 'tuple'], but got {} "
-                         "with type {}".format(axis, type(axis)))

mindspore/_extends/graph_kernel/expanders/fused_adam.py

@@ -1,44 +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"""
-from ._utils import Expander, ExpanderInfoValidator as VLD
-
-
-@VLD.check_all_formats_same
-class FusedAdam(Expander):
-    """FusedAdam expander"""
-
-    def _expand(self, graph_builder):
-        beta_1, one_sub_beta_1, beta_2, one_sub_beta_2, eps, lr, param, m, v, gradient = self.inputs
-
-        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])
-        update_with_lr = graph_builder.emit('Mul', [lr, update])
-        next_para = graph_builder.emit('Sub', [param, update_with_lr])
-
-        param_result = graph_builder.emit(
-            'InplaceAssign', [param, next_para, next_para], attrs={'fake_output': True})
-        param_result = graph_builder.emit('InplaceAssign', [m, next_m, param_result], attrs={'fake_output': True})
-        param_result = graph_builder.emit('InplaceAssign', [v, next_v, param_result], attrs={'fake_output': True})
-
-        return param_result