mindspore 1.10.0__cp37-none-any.whl → 2.0.0rc1__cp37-none-any.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/tbe/bias_add_grad_ds.py

@@ -1,52 +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.
-# ============================================================================
-
-"""BiasAddGrad op"""
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
-
-bias_add_grad_op_info = TBERegOp("BiasAddGrad") \
-    .fusion_type("COMMREDUCE") \
-    .async_flag(False) \
-    .binfile_name("bias_add_grad.so") \
-    .compute_cost(10) \
-    .kernel_name("bias_add_grad") \
-    .partial_flag(True) \
-    .dynamic_shape(True) \
-    .attr("format", "required", "str", "all") \
-    .input(0, "output_backprop", False, "required", "all") \
-    .output(0, "output", False, "required", "all") \
-    .dtype_format(DataType.F16_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F16_FracNZ, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.F32_FracNZ, DataType.F32_Default) \
-    .dtype_format(DataType.F16_FracNZ, DataType.F16_NHWC) \
-    .dtype_format(DataType.F32_FracNZ, DataType.F32_NHWC) \
-    .dtype_format(DataType.F16_Default, DataType.F16_NHWC) \
-    .dtype_format(DataType.F32_Default, DataType.F32_NHWC) \
-    .dtype_format(DataType.F16_NDC1HWC0, DataType.F16_Default) \
-    .dtype_format(DataType.F32_NDC1HWC0, DataType.F32_Default) \
-    .dtype_format(DataType.F16_NDC1HWC0, DataType.F16_NHWC) \
-    .dtype_format(DataType.F32_NDC1HWC0, DataType.F32_NHWC) \
-    .dtype_format(DataType.F16_FRACTAL_Z_3D, DataType.F16_Default) \
-    .dtype_format(DataType.F32_FRACTAL_Z_3D, DataType.F32_Default) \
-    .dtype_format(DataType.F16_FRACTAL_Z_3D, DataType.F16_NHWC) \
-    .dtype_format(DataType.F32_FRACTAL_Z_3D, DataType.F32_NHWC) \
-    .get_op_info()
-
-
-@op_info_register(bias_add_grad_op_info)
-def _bias_add_grad_ds_tbe():
-    """BiasAddGrad TBE register"""
-    return

mindspore/ops/_op_impl/tbe/scatter_nd_add_ds.py

@@ -1,43 +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.
-# ============================================================================
-
-"""ScatterNdAdd op"""
-from mindspore.ops.op_info_register import op_info_register, TBERegOp, DataType
-
-scatter_nd_add_ds_op_info = TBERegOp("ScatterNdAdd") \
-    .fusion_type("ELEMWISE") \
-    .async_flag(False) \
-    .binfile_name("scatter_nd_add.so") \
-    .compute_cost(10) \
-    .kernel_name("scatter_nd_add") \
-    .partial_flag(True) \
-    .dynamic_shape(True) \
-    .attr("use_locking", "optional", "bool", "all", "false") \
-    .input(0, "var", False, "required", "all") \
-    .input(1, "indices", False, "required", "all") \
-    .input(2, "updates", False, "required", "all") \
-    .output(0, "var", False, "required", "all") \
-    .dtype_format(DataType.F16_Default, DataType.I32_Default, DataType.F16_Default, DataType.F16_Default) \
-    .dtype_format(DataType.F32_Default, DataType.I32_Default, DataType.F32_Default, DataType.F32_Default) \
-    .dtype_format(DataType.I8_Default, DataType.I32_Default, DataType.I8_Default, DataType.I8_Default) \
-    .dtype_format(DataType.U8_Default, DataType.I32_Default, DataType.U8_Default, DataType.U8_Default) \
-    .dtype_format(DataType.I32_Default, DataType.I32_Default, DataType.I32_Default, DataType.I32_Default) \
-    .get_op_info()
-
-
-@op_info_register(scatter_nd_add_ds_op_info)
-def _scatter_nd_add_ds_tbe():
-    """ScatterNdAdd TBE register"""
-    return

mindspore/ops/bprop_mindir/AssignAdd_bprop.mindir

@@ -1,20 +0,0 @@
-
-0.1.1	MindSpore*1.9.0:�
-�

-
-bprop.22:xbprop.22:[CNode]23:1bprop.22:[CNode]23:1"(REF::S-Prim-hyper_map[zeros_like_leaf]:2:.Default/S-Prim-hyper_map[zeros_like_leaf]-op15
-�

-
-bprop.22:ybprop.22:[CNode]24:3bprop.22:[CNode]24:3"(REF::S-Prim-hyper_map[zeros_like_leaf]:2:.Default/S-Prim-hyper_map[zeros_like_leaf]-op16
-�

-bprop.22:[CNode]23:1
-bprop.22:[CNode]24:3bprop.22:[CNode]25:4bprop.22:[CNode]25:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op17bprop.22*
-
-bprop.22:x*
-
-bprop.22:y*
-bprop.22:out*
-
-bprop.22:[CNode]25:4:@157abcda70ad669686a320be427dedf2a17498d59a38b65d04c272c1a40296e0P
bH
-#S-Prim-hyper_map[zeros_like_leaf]:2!S-Prim-hyper_map[zeros_like_leaf]b&
-S-Prim-MakeTuple:5S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/Identity_bprop.mindir

@@ -1,9 +0,0 @@
-
-0.1.1	MindSpore*1.9.0:�

-m
-bprop.3:doutbprop.3:[CNode]4:1bprop.3:[CNode]4:1"REF::S-Prim-MakeTuple:2:Default/S-Prim-MakeTuple-op2bprop.3*
-	bprop.3:x*
-bprop.3:out*
-bprop.3:dout2
-bprop.3:[CNode]4:1:@030ffb7e684c8e2604e69bfc02a6e32af82543a97f4aa0a6bc7cab6275ee9b9dP
b&
-S-Prim-MakeTuple:2S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/LogicalOr_bprop.mindir

@@ -1,20 +0,0 @@
-
-0.1.1	MindSpore*1.9.0:�
-�

-
-bprop.89:xbprop.89:[CNode]90:1bprop.89:[CNode]90:1"(REF::S-Prim-hyper_map[zeros_like_leaf]:2:.Default/S-Prim-hyper_map[zeros_like_leaf]-op65
-�

-
-bprop.89:ybprop.89:[CNode]91:3bprop.89:[CNode]91:3"(REF::S-Prim-hyper_map[zeros_like_leaf]:2:.Default/S-Prim-hyper_map[zeros_like_leaf]-op66
-�

-bprop.89:[CNode]90:1
-bprop.89:[CNode]91:3bprop.89:[CNode]92:4bprop.89:[CNode]92:4"REF::S-Prim-MakeTuple:5:Default/S-Prim-MakeTuple-op67bprop.89*
-
-bprop.89:x*
-
-bprop.89:y*
-bprop.89:out*
-
-bprop.89:[CNode]92:4:@157abcda70ad669686a320be427dedf2a17498d59a38b65d04c272c1a40296e0P
b&
-S-Prim-MakeTuple:5S-Prim-MakeTuplebH
-#S-Prim-hyper_map[zeros_like_leaf]:2!S-Prim-hyper_map[zeros_like_leaf]h

mindspore/ops/bprop_mindir/ReLU_bprop.mindir

@@ -1,16 +0,0 @@
-
-0.1.1	MindSpore*1.9.0:�
-l
-bprop.2:dout
-bprop.2:outbprop.2:dx:1bprop.2:dx:1"REF::S-Prim-ReluGrad:2:Default/S-Prim-ReluGrad-op0
-m
-bprop.2:dx:1bprop.2:[CNode]3:3bprop.2:[CNode]3:3"REF::S-Prim-MakeTuple:4:Default/S-Prim-MakeTuple-op1bprop.2*
-	bprop.2:x*
-bprop.2:out*
-bprop.2:dout2
-bprop.2:[CNode]3:3:@a4eb13bf27055f09658e34801dd3ecb26dde55844e65250300ce08b9cb6e3299P
br
-S-Prim-ReluGrad:2S-Prim-ReluGrad
-output_names�
�
Zoutput�
+
-input_names�
�
Z
-y_backprop�
�
Z
x�
b&
-S-Prim-MakeTuple:4S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/UpdateState_bprop.mindir

@@ -1,17 +0,0 @@
-
-0.1.1	MindSpore*1.9.0:�
-�

-bprop_update_state.19:u_monad!bprop_update_state.19:[CNode]20:1!bprop_update_state.19:[CNode]20:1"(REF::S-Prim-hyper_map[zeros_like_leaf]:2:.Default/S-Prim-hyper_map[zeros_like_leaf]-op14
-�

-bprop_update_state.19:x!bprop_update_state.19:[CNode]21:3!bprop_update_state.19:[CNode]21:3"(REF::S-Prim-hyper_map[zeros_like_leaf]:4:.Default/S-Prim-hyper_map[zeros_like_leaf]-op15
-�

-!bprop_update_state.19:[CNode]20:1
-!bprop_update_state.19:[CNode]21:3!bprop_update_state.19:[CNode]22:5!bprop_update_state.19:[CNode]22:5"REF::S-Prim-MakeTuple:6:Default/S-Prim-MakeTuple-op16bprop_update_state.19*
-bprop_update_state.19:u_monad*
-bprop_update_state.19:x*
-bprop_update_state.19:out*
-bprop_update_state.19:dout2#
-!bprop_update_state.19:[CNode]22:5:@5762fbec96d9311f48905028e4687b3c255d34c9501710bc8a449a228b23a28eP
bH
-#S-Prim-hyper_map[zeros_like_leaf]:4!S-Prim-hyper_map[zeros_like_leaf]bH
-#S-Prim-hyper_map[zeros_like_leaf]:2!S-Prim-hyper_map[zeros_like_leaf]b&
-S-Prim-MakeTuple:6S-Prim-MakeTupleh

mindspore/ops/bprop_mindir/stop_gradient_bprop.mindir

@@ -1,12 +0,0 @@
-
-0.1.1	MindSpore*1.9.0:�
-�

-bprop_stop_gradient.9:x!bprop_stop_gradient.9:[CNode]10:1!bprop_stop_gradient.9:[CNode]10:1"(REF::S-Prim-hyper_map[zeros_like_leaf]:2:-Default/S-Prim-hyper_map[zeros_like_leaf]-op6
-�

-!bprop_stop_gradient.9:[CNode]10:1!bprop_stop_gradient.9:[CNode]11:3!bprop_stop_gradient.9:[CNode]11:3"REF::S-Prim-MakeTuple:4:Default/S-Prim-MakeTuple-op7bprop_stop_gradient.9*
-bprop_stop_gradient.9:x*
-bprop_stop_gradient.9:out*
-bprop_stop_gradient.9:dout2#
-!bprop_stop_gradient.9:[CNode]11:3:@5762fbec96d9311f48905028e4687b3c255d34c9501710bc8a449a228b23a28eP
b&
-S-Prim-MakeTuple:4S-Prim-MakeTuplebH
-#S-Prim-hyper_map[zeros_like_leaf]:2!S-Prim-hyper_map[zeros_like_leaf]h