mindspore 2.0.0a0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/nn/probability/transforms/transform_bnn.py

@@ -1,262 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-"""Transform DNN to BNN."""
-import mindspore.nn as nn
-from ...wrap.cell_wrapper import TrainOneStepCell
-from ....nn import optim
-from ....nn import layer
-from ...probability import bnn_layers
-from ..bnn_layers.bnn_cell_wrapper import WithBNNLossCell
-from ..bnn_layers.conv_variational import ConvReparam
-from ..bnn_layers.dense_variational import DenseReparam
-
-__all__ = ['TransformToBNN']
-
-
-class TransformToBNN:
-    r"""
-    Transform Deep Neural Network (DNN) model to Bayesian Neural Network (BNN) model.
-
-    Args:
-        trainable_dnn (Cell): A trainable DNN model (backbone) wrapped by TrainOneStepCell.
-        dnn_factor (int, float): The coefficient of backbone's loss, which is computed by loss function. Default: 1.
-        bnn_factor (int, float): The coefficient of KL loss, which is KL divergence of Bayesian layer. Default: 1.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU``
-
-    Examples:
-        >>> from mindspore.nn.probability import bnn_layers
-        >>>
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.conv = nn.Conv2d(3, 64, 3, has_bias=False, weight_init='normal')
-        ...         self.bn = nn.BatchNorm2d(64)
-        ...         self.relu = nn.ReLU()
-        ...         self.flatten = nn.Flatten()
-        ...         self.fc = nn.Dense(64*224*224, 12) # padding=0
-        ...
-        ...     def construct(self, x):
-        ...         x = self.conv(x)
-        ...         x = self.bn(x)
-        ...         x = self.relu(x)
-        ...         x = self.flatten(x)
-        ...         out = self.fc(x)
-        ...         return out
-        >>>
-        >>> net = Net()
-        >>> criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-        >>> optim = nn.AdamWeightDecay(params=net.trainable_params(), learning_rate=0.0001)
-        >>> net_with_loss = nn.WithLossCell(net, criterion)
-        >>> train_network = nn.TrainOneStepCell(net_with_loss, optim)
-        >>> bnn_transformer = TransformToBNN(train_network, 60000, 0.0001)
-    """
-
-    def __init__(self, trainable_dnn, dnn_factor=1, bnn_factor=1):
-        if isinstance(dnn_factor, bool) or not isinstance(dnn_factor, (int, float)):
-            raise TypeError('The type of `dnn_factor` must be `int` or `float`')
-        if dnn_factor < 0:
-            raise ValueError('The value of `dnn_factor` must >= 0')
-
-        if isinstance(bnn_factor, bool) or not isinstance(bnn_factor, (int, float)):
-            raise TypeError('The type of `bnn_factor` must be `int` or `float`')
-        if bnn_factor < 0:
-            raise ValueError('The value of `bnn_factor` must >= 0')
-
-        net_with_loss = trainable_dnn.network
-        self.optimizer = trainable_dnn.optimizer
-        self.backbone = net_with_loss.backbone_network
-        self.loss_fn = getattr(net_with_loss, "_loss_fn")
-        self.dnn_factor = dnn_factor
-        self.bnn_factor = bnn_factor
-
-    def transform_to_bnn_model(self,
-                               get_dense_args=lambda dp: {"in_channels": dp.in_channels, "has_bias": dp.has_bias,
-                                                          "out_channels": dp.out_channels,
-                                                          "activation": dp.activation},
-                               get_conv_args=lambda dp: {"in_channels": dp.in_channels,
-                                                         "out_channels": dp.out_channels,
-                                                         "pad_mode": dp.pad_mode, "kernel_size": dp.kernel_size,
-                                                         "stride": dp.stride, "has_bias": dp.has_bias,
-                                                         "padding": dp.padding, "dilation": dp.dilation,
-                                                         "group": dp.group},
-                               add_dense_args=None,
-                               add_conv_args=None):
-        r"""
-        Transform the whole DNN model to BNN model, and wrap BNN model by TrainOneStepCell.
-
-        Args:
-            get_dense_args: The arguments gotten from the DNN full connection layer. Default: lambda dp:
-                {"in_channels": dp.in_channels, "out_channels": dp.out_channels, "has_bias": dp.has_bias}.
-            get_conv_args: The arguments gotten from the DNN convolutional layer. Default: lambda dp:
-                {"in_channels": dp.in_channels, "out_channels": dp.out_channels, "pad_mode": dp.pad_mode,
-                "kernel_size": dp.kernel_size, "stride": dp.stride, "has_bias": dp.has_bias}.
-            add_dense_args (dict): The new arguments added to BNN full connection layer. Note that the arguments in
-                `add_dense_args` must not duplicate arguments in `get_dense_args`. Default: None.
-            add_conv_args (dict): The new arguments added to BNN convolutional layer. Note that the arguments in
-                `add_conv_args` must not duplicate arguments in `get_conv_args`. Default: None.
-
-        Returns:
-            Cell, a trainable BNN model wrapped by TrainOneStepCell.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU``
-
-        Examples:
-            >>> net = Net()
-            >>> criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-            >>> optim = nn.AdamWeightDecay(params=net.trainable_params(), learning_rate=0.0001)
-            >>> net_with_loss = nn.WithLossCell(net, criterion)
-            >>> train_network = nn.TrainOneStepCell(net_with_loss, optim)
-            >>> bnn_transformer = TransformToBNN(train_network, 60000, 0.1)
-            >>> train_bnn_network = bnn_transformer.transform_to_bnn_model()
-        """
-        if not add_dense_args:
-            add_dense_args = {}
-        if not add_conv_args:
-            add_conv_args = {}
-
-        self._replace_all_bnn_layers(self.backbone, get_dense_args, get_conv_args, add_dense_args, add_conv_args)
-
-        # rename layers of BNN model to prevent duplication of names
-        for value, param in self.backbone.parameters_and_names():
-            param.name = value
-
-        bnn_with_loss = WithBNNLossCell(self.backbone, self.loss_fn, self.dnn_factor, self.bnn_factor)
-        bnn_optimizer = self._create_optimizer_with_bnn_params()
-        train_bnn_network = TrainOneStepCell(bnn_with_loss, bnn_optimizer)
-        return train_bnn_network
-
-    def transform_to_bnn_layer(self, dnn_layer_type, bnn_layer_type, get_args=None, add_args=None):
-        r"""
-        Transform a specific type of layers in DNN model to corresponding BNN layer.
-
-        Args:
-            dnn_layer_type (Cell): The type of DNN layer to be transformed to BNN layer. The optional values are
-                nn.Dense and nn.Conv2d.
-            bnn_layer_type (Cell): The type of BNN layer to be transformed to. The optional values are
-                DenseReparam and ConvReparam.
-            get_args: The arguments gotten from the DNN layer. Default: None.
-            add_args (dict): The new arguments added to BNN layer. Note that the arguments in `add_args` must not
-                duplicate arguments in `get_args`. Default: None.
-
-        Returns:
-            Cell, a trainable model wrapped by TrainOneStepCell, whose specific type of layer is transformed to the
-            corresponding bayesian layer.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU``
-
-        Examples:
-            >>> import mindspore.nn as nn
-            >>> from mindspore.nn.probability import bnn_layers
-            >>> net = LeNet()
-            >>> criterion = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-            >>> optim = nn.AdamWeightDecay(params=net.trainable_params(), learning_rate=0.0001)
-            >>> net_with_loss = nn.WithLossCell(net, criterion)
-            >>> train_network = nn.TrainOneStepCell(net_with_loss, optim)
-            >>> bnn_transformer = TransformToBNN(train_network, 60000, 0.1)
-            >>> train_bnn_network = bnn_transformer.transform_to_bnn_layer(nn.Dense, bnn_layers.DenseReparam)
-        """
-        if dnn_layer_type.__name__ not in ["Dense", "Conv2d"]:
-            raise ValueError(' \'dnn_layer\'' + str(dnn_layer_type) +
-                             ', should be one of values in \'nn.Dense\', \'nn.Conv2d\'.')
-
-        if bnn_layer_type.__name__ not in ["DenseReparam", "ConvReparam"]:
-            raise ValueError(' \'bnn_layer\'' + str(bnn_layer_type) +
-                             ', should be one of values in \'DenseReparam\', \'ConvReparam\'.')
-
-        dnn_layer_type = getattr(layer, dnn_layer_type.__name__)
-        bnn_layer_type = getattr(bnn_layers, bnn_layer_type.__name__)
-
-        if not get_args:
-            if dnn_layer_type.__name__ == "Dense":
-                get_args = self._get_dense_args
-            else:
-                get_args = self._get_conv_args
-
-        if not add_args:
-            add_args = {}
-
-        self._replace_specified_dnn_layers(self.backbone, dnn_layer_type, bnn_layer_type, get_args, add_args)
-        for value, param in self.backbone.parameters_and_names():
-            param.name = value
-
-        bnn_with_loss = WithBNNLossCell(self.backbone, self.loss_fn, self.dnn_factor, self.bnn_factor)
-        bnn_optimizer = self._create_optimizer_with_bnn_params()
-
-        train_bnn_network = TrainOneStepCell(bnn_with_loss, bnn_optimizer)
-        return train_bnn_network
-
-    def _get_dense_args(self, dense_layer):
-        """Get arguments from dense layer."""
-        dense_args = {"in_channels": dense_layer.in_channels, "has_bias": dense_layer.has_bias,
-                      "out_channels": dense_layer.out_channels, "activation": dense_layer.activation}
-        return dense_args
-
-    def _get_conv_args(self, conv_layer):
-        """Get arguments from conv2d layer."""
-        conv_args = {"in_channels": conv_layer.in_channels, "out_channels": conv_layer.out_channels,
-                     "pad_mode": conv_layer.pad_mode, "kernel_size": conv_layer.kernel_size,
-                     "stride": conv_layer.stride, "has_bias": conv_layer.has_bias,
-                     "padding": conv_layer.padding, "dilation": conv_layer.dilation,
-                     "group": conv_layer.group}
-        return conv_args
-
-    def _create_optimizer_with_bnn_params(self):
-        """Create new optimizer that contains bnn trainable parameters."""
-        name = self.optimizer.__class__.__name__
-        modules = optim.__all__
-
-        if name not in modules:
-            raise TypeError('The optimizer can be {}, but got {}'.format(str(modules), name))
-
-        optimizer = getattr(optim, name)
-
-        args = {'params': self.backbone.trainable_params()}
-        params = optimizer.__init__.__code__.co_varnames
-        _params = self.optimizer.__dict__['_params']
-        for param in params:
-            if param in _params:
-                args[param] = self.optimizer.__getattr__(param).data.asnumpy().tolist()
-
-        new_optimizer = optimizer(**args)
-        return new_optimizer
-
-    def _replace_all_bnn_layers(self, backbone, get_dense_args, get_conv_args, add_dense_args, add_conv_args):
-        """Replace both dense layer and conv2d layer in DNN model to bayesian layers."""
-        for name, cell in backbone.name_cells().items():
-            if isinstance(cell, nn.Dense):
-                dense_args = get_dense_args(cell)
-                new_layer = DenseReparam(**dense_args, **add_dense_args)
-                setattr(backbone, name, new_layer)
-            elif isinstance(cell, nn.Conv2d):
-                conv_args = get_conv_args(cell)
-                new_layer = ConvReparam(**conv_args, **add_conv_args)
-                setattr(backbone, name, new_layer)
-            else:
-                self._replace_all_bnn_layers(cell, get_dense_args, get_conv_args, add_dense_args,
-                                             add_conv_args)
-
-    def _replace_specified_dnn_layers(self, backbone, dnn_layer, bnn_layer, get_args, add_args):
-        """Convert a specific type of layers in DNN model to corresponding bayesian layers."""
-        for name, cell in backbone.name_cells().items():
-            if isinstance(cell, dnn_layer):
-                args = get_args(cell)
-                new_layer = bnn_layer(**args, **add_args)
-                setattr(backbone, name, new_layer)
-            else:
-                self._replace_specified_dnn_layers(cell, dnn_layer, bnn_layer, get_args, add_args)

mindspore/nn/probability/zhusuan/__init__.py

@@ -1,18 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-""" Zhusuan package: a probalistic programming library  """
-
-from .framework import BayesianNet
-from .variational import ELBO

mindspore/nn/probability/zhusuan/framework/__init__.py

@@ -1,18 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-""" Core functionality for Zhusuan """
-
-from .bn import BayesianNet

mindspore/nn/probability/zhusuan/framework/bn.py

@@ -1,95 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-""" Bayesian Network """
-
-import mindspore.nn as nn
-
-import mindspore.nn.probability.distribution as msd
-from mindspore.common import dtype as mstype
-from mindspore.ops import operations as P
-
-
-class BayesianNet(nn.Cell):
-    """
-    We currently support 3 types of variables: x = observation, z = latent, y = condition.
-    A Bayeisian Network models a generative process for certain variables: p(x,z|y) or p(z|x,y) or p(x|z,y)
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.normal_dist = msd.Normal(dtype=mstype.float32)
-        self.bernoulli_dist = msd.Bernoulli(dtype=mstype.float32)
-
-        self.reduce_sum = P.ReduceSum(keep_dims=True)
-
-    def normal(self,
-               name,
-               observation=None,
-               mean=None,
-               std=None,
-               seed=0,
-               dtype=mstype.float32,
-               shape=(),
-               reparameterize=True):
-        """ Normal distribution wrapper """
-
-        if not isinstance(name, str):
-            raise TypeError("The type of `name` must be string")
-
-        if observation is None:
-            if reparameterize:
-                epsilon = self.normal_dist('sample', shape, self.zeros(
-                    mean.shape), self.ones(std.shape))
-                sample = mean + std * epsilon
-            else:
-                sample = self.normal_dist('sample', shape, mean, std)
-        else:
-            sample = observation
-
-        log_prob = self.reduce_sum(self.normal_dist(
-            'log_prob', sample, mean, std), 1)
-        return sample, log_prob
-
-    def bernoulli(self,
-                  name,
-                  observation=None,
-                  probs=None,
-                  seed=0,
-                  dtype=mstype.float32,
-                  shape=()):
-        """ Bernoulli distribution wrapper """
-
-        if not isinstance(name, str):
-            raise TypeError("The type of `name` must be string")
-
-        if observation is None:
-            sample = self.bernoulli_dist('sample', shape, probs)
-        else:
-            sample = observation
-
-        log_prob = self.reduce_sum(
-            self.bernoulli_dist('log_prob', sample, probs), 1)
-        return sample, log_prob
-
-    def construct(self, *inputs, **kwargs):
-        """
-        We currently fix the parameters of the construct function.
-        Args:
-            the inputs must consist of 3 variables in order.
-            x: data sample, observation
-            z: latent variable
-            y: conditional information
-        """
-        raise NotImplementedError

mindspore/nn/probability/zhusuan/variational/__init__.py

@@ -1,18 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-""" Variational inference related codes """
-
-from .elbo import ELBO

mindspore/nn/probability/zhusuan/variational/elbo.py

@@ -1,46 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-""" ELBO """
-
-import mindspore.nn as nn
-
-from mindspore.ops import operations as P
-
-
-class ELBO(nn.Cell):
-    """ ELBO class """
-    def __init__(self, generator, variational):
-        super().__init__()
-        self.generator = generator
-        self.variational = variational
-        self.reshape_op = P.Reshape()
-        self.reduce_mean = P.ReduceMean(keep_dims=False)
-        self.square = P.Square()
-
-    def construct(self, *inputs, **kwargs):
-        if len(inputs) >= 2:
-            x, y = inputs[0], inputs[1]
-        elif len(inputs) >= 1:
-            x = inputs[0]
-            y = None
-        else:
-            x = None
-            y = None
-
-        z, log_prob_z = self.variational(x, None, y)
-        _, log_prob_x_, _, log_prob_z_ = self.generator(x, z, y)
-
-        elbo = self.reduce_mean(log_prob_x_) + self.reduce_mean(log_prob_z_) - self.reduce_mean(log_prob_z)
-        return -elbo

mindspore/ops/_op_impl/aicpu/parallel_concat.py

@@ -1,42 +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.
-# ============================================================================
-
-"""ParallelConcat op"""
-from mindspore.ops.op_info_register import op_info_register, AiCPURegOp, DataType
-
-parallel_concat_op_info = AiCPURegOp("ParallelConcat")          \
-    .fusion_type("OPAQUE")                                      \
-    .input(0, "x", "dynamic")                                   \
-    .output(0, "y", "required")                                 \
-    .dtype_format(DataType.U8_Default, DataType.U8_Default)     \
-    .dtype_format(DataType.U16_Default, DataType.U16_Default)   \
-    .dtype_format(DataType.U32_Default, DataType.U32_Default)   \
-    .dtype_format(DataType.U64_Default, DataType.U64_Default)   \
-    .dtype_format(DataType.I8_Default, DataType.I8_Default)     \
-    .dtype_format(DataType.I16_Default, DataType.I16_Default)   \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default)   \
-    .dtype_format(DataType.I64_Default, DataType.I64_Default)   \
-    .dtype_format(DataType.F16_Default, DataType.F16_Default)   \
-    .dtype_format(DataType.F32_Default, DataType.F32_Default)   \
-    .dtype_format(DataType.F64_Default, DataType.F64_Default)   \
-    .dtype_format(DataType.C64_Default, DataType.C64_Default)   \
-    .dtype_format(DataType.C128_Default, DataType.C128_Default) \
-    .get_op_info()
-
-
-@op_info_register(parallel_concat_op_info)
-def _parallel_concat_aicpu():
-    """ParallelConcat AiCPU register"""
-    return

mindspore/ops/_op_impl/tbe/gather_v2.py

@@ -1,56 +0,0 @@
-# Copyright 2020 Huawei Technologies Co., Ltd
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ============================================================================
-
-"""GatherV2 op"""
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
-
-gather_v2_op_info = TBERegOp("Gather") \
-    .fusion_type("OPAQUE") \
-    .async_flag(False) \
-    .binfile_name("gather_v2_d.so") \
-    .compute_cost(10) \
-    .kernel_name("gather_v2_d") \
-    .partial_flag(True) \
-    .attr("axis", "required", "int", "all") \
-    .input(0, "x", False, "required", "all") \
-    .input(1, "indices", False, "required", "all") \
-    .output(0, "y", False, "required", "all") \
-    .dtype_format(DataType.F16_Default, DataType.I32_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
-    .dtype_format(DataType.U32_Default, DataType.I32_Default, DataType.U32_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I32_Default, DataType.I16_Default) \
-    .dtype_format(DataType.U16_Default, DataType.I32_Default, DataType.U16_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I32_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U64_Default, DataType.I32_Default, DataType.U64_Default) \
-    .dtype_format(DataType.F16_Default, DataType.I64_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.I64_Default, DataType.F32_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I64_Default, DataType.I8_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I64_Default, DataType.U8_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I64_Default, DataType.I32_Default) \
-    .dtype_format(DataType.U32_Default, DataType.I64_Default, DataType.U32_Default) \
-    .dtype_format(DataType.I16_Default, DataType.I64_Default, DataType.I16_Default) \
-    .dtype_format(DataType.U16_Default, DataType.I64_Default, DataType.U16_Default) \
-    .dtype_format(DataType.I64_Default, DataType.I64_Default, DataType.I64_Default) \
-    .dtype_format(DataType.U64_Default, DataType.I64_Default, DataType.U64_Default) \
-    .get_op_info()
-
-
-@op_info_register(gather_v2_op_info)
-def _gather_v2_tbe():
-    """GatherV2 TBE register"""
-    return

mindspore/ops/bprop_mindir/AssignAdd_bprop.mindir

@@ -1,19 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-}'get_bprop_assign_add.1231:[CNode]1232:1'get_bprop_assign_add.1231:[CNode]1232:1"REF::bprop.1233:Default/bprop.1233-op958get_bprop_assign_add.1231* 
-get_bprop_assign_add.1231:self*
-get_bprop_assign_add.1231:x*
-get_bprop_assign_add.1231:y*
-get_bprop_assign_add.1231:out* 
-get_bprop_assign_add.1231:dout2)
-'get_bprop_assign_add.1231:[CNode]1232:1:@864154f4834e62d84d34aab9399558528d5e734f6725d5daf7fbc1907cb32a1aJ/grad_math_ops.pyB�
-�

-get_bprop_assign_add.1231:xbprop.1233:[CNode]1234:2bprop.1233:[CNode]1234:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op959
-�

-get_bprop_assign_add.1231:ybprop.1233:[CNode]1235:3bprop.1233:[CNode]1235:3".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op960
-�

-bprop.1233:[CNode]1234:2
-bprop.1233:[CNode]1235:3bprop.1233:[CNode]1236:4bprop.1233:[CNode]1236:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op961
-bprop.12332
-bprop.1233:[CNode]1236:4P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/Cast_bprop.mindir

@@ -1,19 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-]get_bprop_cast.6:[CNode]7:1get_bprop_cast.6:[CNode]7:1"REF::bprop.8:Default/bprop.8-op3get_bprop_cast.6*
-get_bprop_cast.6:self*
-get_bprop_cast.6:x*
-get_bprop_cast.6:t*
-get_bprop_cast.6:out*
-get_bprop_cast.6:dout2
-get_bprop_cast.6:[CNode]7:1:@2a049f3579950913c6ea42bb677f44470016652aa549a6dee2350ea48d50f039J/grad_array_ops.pyB�
-�

-get_bprop_cast.6:dout
-get_bprop_cast.6:xbprop.8:dx:2bprop.8:dx:2"REF::MetaFuncGraph::dout_cast:Default/S-Prim-dout_cast-op4
-�

-get_bprop_cast.6:tbprop.8:[CNode]9:3bprop.8:[CNode]9:3".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:-Default/S-Prim-hyper_map[zeros_like_leaf]-op5
-�

-bprop.8:dx:2
-bprop.8:[CNode]9:3bprop.8:[CNode]10:4bprop.8:[CNode]10:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op6bprop.82
-bprop.8:[CNode]10:4P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/LogicalOr_bprop.mindir

@@ -1,19 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-}'get_bprop_logical_or.1225:[CNode]1226:1'get_bprop_logical_or.1225:[CNode]1226:1"REF::bprop.1227:Default/bprop.1227-op954get_bprop_logical_or.1225* 
-get_bprop_logical_or.1225:self*
-get_bprop_logical_or.1225:x*
-get_bprop_logical_or.1225:y*
-get_bprop_logical_or.1225:out* 
-get_bprop_logical_or.1225:dout2)
-'get_bprop_logical_or.1225:[CNode]1226:1:@906051cca7d6d4b88a09a10b80bb5f0541066115667786dd7364cba0508be483J/grad_math_ops.pyB�
-�

-get_bprop_logical_or.1225:xbprop.1227:[CNode]1228:2bprop.1227:[CNode]1228:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op955
-�

-get_bprop_logical_or.1225:ybprop.1227:[CNode]1229:3bprop.1227:[CNode]1229:3".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:/Default/S-Prim-hyper_map[zeros_like_leaf]-op956
-�

-bprop.1227:[CNode]1228:2
-bprop.1227:[CNode]1229:3bprop.1227:[CNode]1230:4bprop.1227:[CNode]1230:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op957
-bprop.12272
-bprop.1227:[CNode]1230:4P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/ReLU_bprop.mindir

@@ -1,17 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-q!get_bprop_relu.1273:[CNode]1274:1!get_bprop_relu.1273:[CNode]1274:1"REF::bprop.1275:Default/bprop.1275-op987
-�
 get_bprop_relu.1273:input_grad:2 get_bprop_relu.1273:input_grad:2";REF::ClassType::mindspore.ops.operations._grad_ops.ReluGrad:ADefault/class 'mindspore.ops.operations._grad_ops.ReluGrad'-op988get_bprop_relu.1273*
-get_bprop_relu.1273:self*
-get_bprop_relu.1273:x*
-get_bprop_relu.1273:out*
-get_bprop_relu.1273:dout2#
-!get_bprop_relu.1273:[CNode]1274:1:@92fe953ca276bba8b43b979895a017d6283e879df08b1a28bbae49b041d910b5J/grad_nn_ops.pyB�
-�

-get_bprop_relu.1273:dout
-get_bprop_relu.1273:outbprop.1275:dx:3bprop.1275:dx:3"%REF::get_bprop_relu.1273:input_grad:2:989
-~
-bprop.1275:dx:3bprop.1275:[CNode]1276:4bprop.1275:[CNode]1276:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op990
-bprop.12752
-bprop.1275:[CNode]1276:4P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/UpdateState_bprop.mindir

@@ -1,15 +0,0 @@
-
-0.1.1	MindSpore*2.0.0:�
-�

-bprop_update_state.1331:u_monad%bprop_update_state.1331:[CNode]1332:1%bprop_update_state.1331:[CNode]1332:1".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:0Default/S-Prim-hyper_map[zeros_like_leaf]-op1032
-�

-bprop_update_state.1331:x%bprop_update_state.1331:[CNode]1333:2%bprop_update_state.1331:[CNode]1333:2".REF::MetaFuncGraph::hyper_map[zeros_like_leaf]:0Default/S-Prim-hyper_map[zeros_like_leaf]-op1033
-�

-%bprop_update_state.1331:[CNode]1332:1
-%bprop_update_state.1331:[CNode]1333:2%bprop_update_state.1331:[CNode]1334:3%bprop_update_state.1331:[CNode]1334:3"REF::S-Prim-MakeTuple:4:Default/S-Prim-MakeTuple-op1034bprop_update_state.1331*!
-bprop_update_state.1331:u_monad*
-bprop_update_state.1331:x*
-bprop_update_state.1331:out*
-bprop_update_state.1331:dout2'
-%bprop_update_state.1331:[CNode]1334:3:@adde661b2e2f38680f80f0269960db717f31a852326a1f3bda24e010ea8bb153J/grad_implementations.pyP
b&
-S-Prim-MakeTuple:4S-Prim-MakeTupleh