mindspore 2.1.0__cp37-cp37m-manylinux1_x86_64.whl → 2.2.11__cp37-cp37m-manylinux1_x86_64.whl

mindspore/include/api/net.h

@@ -1,142 +0,0 @@
-/**
- * Copyright 2022-2023 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.
- */
-
-#ifndef MINDSPORE_INCLUDE_API_NET_H
-#define MINDSPORE_INCLUDE_API_NET_H
-
-#include <memory>
-#include <vector>
-#include <unordered_set>
-#include <string>
-#include "include/api/types.h"
-#include "include/api/data_type.h"
-#include "include/api/cfg.h"
-
-namespace mindspore {
-/// \brief Register node or sub network
-#define REG(_name) Register(_name, #_name)
-
-class Expr;
-class NodeImpl;
-class NetImpl;
-class NodeSet;
-class Graph;
-class NetData;
-
-class MS_API NetBase {
- public:
-  NetBase() = default;
-  virtual std::vector<Expr *> operator()(const std::vector<Expr *> &inputs) = 0;
-  virtual uint32_t type() = 0;
-};
-
-class MS_API Node : public NetBase {
- public:
-  Node();
-  virtual ~Node();
-  /// \brief Create output expression from node
-
-  /// \param[in] name Name of input (like "labels" etc.)
-  ///
-  /// \return Expression
-  Expr *Create(std::string name);
-  /// \brief Run node on inputs. This operator is used in Net::construct()
-  ///
-  /// \param[in] inputs Inputs expression for the node.
-  /// \return Output node expression vector
-  std::vector<Expr *> operator()(const std::vector<Expr *> &inputs) override;
-  uint32_t type() final;
-
- private:
-  friend NodeImpl;
-  std::shared_ptr<NodeImpl> impl_ = nullptr;
-};
-
-class MS_API Net : public NetBase, public std::enable_shared_from_this<Net> {
- public:
-  Net();
-  virtual ~Net();
-  explicit Net(std::string name);
-  explicit Net(const Graph &g);
-  /// \brief Define the relation between network inputs and outputs
-  ///
-  /// \param[in] inputs expression vector
-  ///
-  /// \return expression vector
-
-  virtual std::vector<Expr *> construct(const std::vector<Expr *> &inputs);
-  /// \brief Addition operation
-  ///
-  /// \param[in] inputs Two elements to add
-  ///
-  /// \return expression vector (single element)
-
-  /// \brief Execution operator. Connect inputs to outputs via user defined construct
-  ///
-  /// \return expression vector
-
-  std::vector<Expr *> operator()(const std::vector<Expr *> &inputs);
-  void Register(Net *net, std::string &&name);
-  void Register(Node *node, std::string &&name);
-  /// \brief Find the trainable params for the trained network
-  ///
-  /// \return NodeSet for all trainable nodes
-  std::shared_ptr<NodeSet> trainable_params();
-  virtual void Add(NetBase *element);
-  /// \brief Input shape
-  ///
-  /// \param[in] idx input index
-  ///
-  /// \return Specific input shape vector
-  const std::vector<int> InputShape(int idx);
-  /// \brief Output shape
-  ///
-  /// \param[in] idx Output index
-  ///
-  /// \return Specific output shape vector
-  const std::vector<int> OutputShape(int idx);
-  uint32_t type() final;
-
- private:
-  friend NetImpl;
-  friend NetData;
-  std::shared_ptr<NetImpl> impl_;
-};
-
-class MS_API SoftMaxCrossEntropyCfg {
- public:
-  std::string reduction = "mean"; /**<  Specifies reduction mode. The optional values are "none", "mean", "sum" */
-};
-
-class MS_API AdamConfig {
- public:
-  float learning_rate_ = 1e-3;
-  float beta1_ = 0.9;
-  float beta2_ = 0.999;
-  float eps_ = 1e-08;
-  bool use_nesterov_ = false;
-};
-
-namespace NN {
-MS_API Net *NetWithLoss(Net *net, Node *loss);
-MS_API Graph *GraphWithLoss(Graph *g, Node *loss);
-MS_API Node *Adam(std::shared_ptr<NodeSet> learn, const AdamConfig &cfg);
-MS_API Node *SoftmaxCrossEntropy(const SoftMaxCrossEntropyCfg &cfg);
-MS_API std::unique_ptr<Node> Input(std::vector<int> dims, DataType data_type = DataType::kNumberTypeFloat32,
-                                   int fmt = NHWC);
-};  // namespace NN
-}  // namespace mindspore
-#endif  // MINDSPORE_INCLUDE_API_NET_H

mindspore/nn/lr_scheduler.py

@@ -1,262 +0,0 @@
-# Copyright 2023 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.
-# ============================================================================
-"""LRScheduler."""
-from mindspore import ops
-from mindspore.nn.optim_ex.optimizer import Optimizer
-from mindspore.common.api import jit_class
-from mindspore.common.parameter import Parameter
-from mindspore.common import Tensor
-import mindspore.common.dtype as mstype
-from mindspore.ops import functional as F
-from mindspore import _checkparam as Validator
-
-
-__all__ = ['StepLR', 'LinearLR', 'LRScheduler']
-
-
-@jit_class
-class LRScheduler():
-    r"""
-    Basic class of learning rate schedule.
-
-    .. warning::
-        This is an experimental lr scheduler module that is subject to change.
-        This module must be used with optimizers in `Experimental Optimizer
-        <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.nn.html#experimental-optimizer>`_ .
-
-    Args:
-        optimizer (:class:`mindspore.nn.optim_ex.Optimizer`): The optimizer instance.
-        last_epoch (int, optional): The epoch/step number. Default: ``-1``.
-        verbose (bool, optional): Whether to print lr information. Default: ``False``.
-
-    Raises:
-        TypeError: If `optimizer` is not an Optimizer.
-        TypeError: If `last_epoch` is not greater than -1.
-        ValueError: If `verbose` is not bool.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-
-    def __init__(self, optimizer, last_epoch=-1, verbose=False):
-        if not isinstance(optimizer, Optimizer):
-            raise TypeError('{} is not an Optimizer'.format(
-                type(optimizer).__name__))
-        Validator.check_value_type("last_epoch", last_epoch, [int])
-        if last_epoch < -1:
-            raise ValueError("Invalid last_epoch: {}".format(last_epoch))
-        Validator.check_value_type("verbose", verbose, [bool])
-
-        self.optimizer = optimizer
-        self._last_lr = []
-        self.groups_num = len(optimizer.param_groups)
-        self.verbose = verbose
-        self.last_epoch = Parameter(Tensor(last_epoch, dtype=mstype.float32),
-                                    name='last_epoch_' + self.__class__.__name__)
-        self.increase_tensor = Tensor(1, mstype.int32)
-        self.assignadd = ops.AssignAdd()
-        self.step()
-
-    @staticmethod
-    def _get_lr():
-        """
-        Compute current lr.
-
-        This method must be overridden by all subclasses.
-        """
-        raise NotImplementedError
-
-    @staticmethod
-    def _print_lr(is_verbose, group, lr):
-        """
-        Display the current learning rate.
-        """
-        if is_verbose:
-            print('Adjusting learning rate of group %s to %s.' % (group, lr.value()))
-
-    def get_last_lr(self):
-        """
-        Return last computed learning rate by current scheduler.
-        """
-        return [group["lr"].value() for group in self.optimizer.param_groups]
-
-    def step(self):
-        """
-        Get the current learning rate and change the learning rate.
-        """
-        self.assignadd(self.last_epoch, self.increase_tensor)
-        values = self._get_lr()
-        for i in range(self.groups_num):
-            lr = values[i]
-            lr = F.depend(lr, F.assign(self.optimizer.param_groups[i]["lr"], lr))
-            self._print_lr(self.verbose, i, lr)
-
-
-@jit_class
-class StepLR(LRScheduler):
-    """Decays the learning rate of each parameter group by gamma every
-    step_size epochs. Notice that such decay can happen simultaneously with
-    other changes to the learning rate from outside this scheduler.
-
-    .. warning::
-        This is an experimental lr scheduler module that is subject to change.
-        This module must be used with optimizers in `Experimental Optimizer
-        <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.nn.html#experimental-optimizer>`_ .
-
-    Args:
-        optimizer (:class:`mindspore.nn.optim_ex.Optimizer`): Wrapped optimizer.
-        step_size (int): Period of learning rate decay.
-        gamma (float, optional): Multiplicative factor of learning rate decay.
-            Default: ``0.1``.
-        last_epoch (int, optional): The index of last epoch. Default: ``-1``.
-        verbose (bool, optional): If ``True``, prints a message to stdout for
-            each update. Default: ``False``.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import nn
-        >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
-        >>> net = LeNet5()
-        >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-        >>> optimizer = nn.optim_ex.Adam(net.trainable_params(), lr=0.05)
-        >>> # Assuming optimizer uses lr = 0.05 for all groups
-        >>> # lr = 0.05     if epoch < 2
-        >>> # lr = 0.005    if 2 <= epoch < 4
-        >>> # lr = 0.0005   if 4 <= epoch < 6
-        >>> scheduler = nn.StepLR(optimizer, step_size=2, gamma=0.1)
-        >>> def forward_fn(data, label):
-        ...     logits = net(data)
-        ...     loss = loss_fn(logits, label)
-        ...     return loss, logits
-        >>> grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
-        >>> def train_step(data, label):
-        ...     (loss, _), grads = grad_fn(data, label)
-        ...     optimizer(grads)
-        ...     return loss
-        >>> for epoch in range(6):
-        ...     # Create the dataset taking MNIST as an example. Refer to
-        ...     # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/mnist.py
-        ...     for data, label in create_dataset():
-        ...         train_step(data, label)
-        ...     scheduler.step()
-        ...     current_lr = scheduler.get_last_lr()
-    """
-    def __init__(self, optimizer, step_size, gamma=0.5, last_epoch=-1, verbose=False):
-        self.step_size = step_size
-        self.gamma = gamma
-        super(StepLR, self).__init__(optimizer, last_epoch, verbose)
-
-    def _get_lr(self):
-        if (self.last_epoch == Tensor(0, mstype.float32)) or (
-                self.last_epoch % self.step_size != Tensor(0, mstype.float32)):
-            return [group['lr'] * 1. for group in self.optimizer.param_groups]
-        return [group['lr'] * self.gamma
-                for group in self.optimizer.param_groups]
-
-
-@jit_class
-class LinearLR(LRScheduler):
-    """Decays the learning rate of each parameter group by linearly changing small
-    multiplicative factor until the number of epoch reaches a pre-defined milestone: total_iters.
-    Notice that such decay can happen simultaneously with other changes to the learning rate
-    from outside this scheduler.
-
-    .. warning::
-        This is an experimental lr scheduler module that is subject to change.
-        This module must be used with optimizers in `Experimental Optimizer
-        <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore.nn.html#experimental-optimizer>`_ .
-
-    Args:
-        optimizer (:class:`mindspore.nn.optim_ex.Optimizer`): Wrapped optimizer.
-        start_factor (float, optional): The number we multiply learning rate in the first epoch.
-            The multiplication factor changes towards `end_factor` in the following epochs.
-            Default: ``1.0 /3``.
-        end_factor (float, optional): The number we multiply learning rate at the end of linear changing
-            process. Default: ``1.0``.
-        total_iters (int, optional): The number of iterations that multiplicative factor reaches to 1.
-            Default: ``5``.
-        last_epoch (int, optional): The index of the last epoch. Default: ``-1``.
-        verbose (bool, optional): If ``True``, prints a message to stdout for
-            each update. Default: ``False``.
-
-    Raises:
-        ValueError: If `start_factor` is not in the range of (0, 1].
-        ValueError: If `end_factor` is not in the range of [0, 1].
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore.nn import LinearLR
-        >>> from mindspore import nn
-        >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
-        >>> net = LeNet5()
-        >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True)
-        >>> optimizer = nn.optim_ex.Adam(net.trainable_params(), lr=0.05)
-        >>> # Assuming optimizer uses lr = 0.05 for all groups
-        >>> # lr = 0.025    if epoch == 0
-        >>> # lr = 0.03125  if epoch == 1
-        >>> # lr = 0.0375   if epoch == 2
-        >>> # lr = 0.04375  if epoch == 3
-        >>> # lr = 0.05    if epoch >= 4
-        >>> scheduler = LinearLR(optimizer, start_factor=0.5, total_iters=4)
-        >>> def forward_fn(data, label):
-        ...     logits = net(data)
-        ...     loss = loss_fn(logits, label)
-        ...     return loss, logits
-        >>> grad_fn = mindspore.value_and_grad(forward_fn, None, optimizer.parameters, has_aux=True)
-        >>> def train_step(data, label):
-        ...     (loss, _), grads = grad_fn(data, label)
-        ...     optimizer(grads)
-        ...     return loss
-        >>> for epoch in range(5):
-        ...     # Create the dataset taking MNIST as an example. Refer to
-        ...     # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/mnist.py
-        ...     for data, label in create_dataset():
-        ...         train_step(data, label)
-        ...     scheduler.step()
-        ...     current_lr = scheduler.get_last_lr()
-    """
-
-    def __init__(self, optimizer, start_factor=1.0 / 3, end_factor=1.0, total_iters=5, last_epoch=-1,
-                 verbose=False):
-
-        if start_factor > 1.0 or start_factor <= 0:
-            raise ValueError('Starting multiplicative factor expected to be greater than 0 and less or equal to 1.')
-
-        if end_factor > 1.0 or end_factor < 0:
-            raise ValueError('Ending multiplicative factor expected to be between 0 and 1.')
-
-        self.start_factor = start_factor
-        self.end_factor = end_factor
-        self.total_iters = total_iters
-        super(LinearLR, self).__init__(optimizer, last_epoch, verbose)
-
-    def _get_lr(self):
-        if self.last_epoch == Tensor(0, mstype.float32):
-            return [group['lr'] * self.start_factor for group in self.optimizer.param_groups]
-
-        if self.last_epoch > self.total_iters:
-            return [group['lr'] * 1. for group in self.optimizer.param_groups]
-
-        return [group['lr'] * (1. + (self.end_factor - self.start_factor) /
-                               (self.total_iters * self.start_factor + (self.last_epoch - 1) *
-                                (self.end_factor - self.start_factor))) for group in self.optimizer.param_groups]

mindspore/ops/_grad_experimental/grad_image_ops.py

@@ -1,248 +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.
-# ============================================================================
-
-"""image_ops"""
-
-from mindspore import Tensor
-from mindspore.common import dtype as mstype
-from mindspore.ops._grad_experimental.grad_base import bprop_getters
-from mindspore.ops import operations as P
-from mindspore.ops import functional as F
-from mindspore.ops.operations import _grad_ops as G
-from mindspore.ops.operations.image_ops import ResizeBicubic
-from mindspore.ops.operations._grad_ops import ResizeBicubicGrad
-from mindspore.ops.operations.image_ops import ResizeV2
-from mindspore.ops.composite.multitype_ops.zeros_like_impl import zeros_like
-from mindspore.ops.operations.image_ops import CropAndResize
-from mindspore.ops.operations.image_ops import CropAndResizeGradImage
-from mindspore.ops.operations.image_ops import CropAndResizeGradBoxes
-from mindspore.ops.operations.image_ops import RGBToHSV
-from mindspore.ops.operations.image_ops import ScaleAndTranslate
-from mindspore import context
-
-
-@bprop_getters.register(ResizeBicubic)
-def get_bprop_resize_bicubic(self):
-    """Grad definition for `ResizeBicubic` operation."""
-    resize_bicubic_grad = ResizeBicubicGrad(align_corners=self.align_corners,
-                                            half_pixel_centers=self.half_pixel_centers)
-
-    def bprop(images, size, out, dout):
-        dx = resize_bicubic_grad(dout, images)
-        return (dx, P.ZerosLike()(size))
-    return bprop
-
-
-@bprop_getters.register(ResizeV2)
-def get_bprop_resize_v2(self):
-    """Grad definition for `ResizeV2` operation."""
-    resize_v2_grad = G.ResizeV2Grad(coordinate_transformation_mode=self.coordinate_transformation_mode,
-                                    mode=self.mode)
-
-    def bprop(x, roi, scales, sizes, out, dout):
-        input_size = P.Shape()(x)
-        dx = resize_v2_grad(dout, roi, scales, Tensor(input_size))
-        return (dx, zeros_like(roi), zeros_like(scales), zeros_like(sizes))
-    return bprop
-
-
-@bprop_getters.register(CropAndResize)
-def get_bprop_crop_and_resize(self):
-    """Grad definition for `CropAndResize` operation."""
-    allowed_types = [mstype.float16, mstype.float32, mstype.float64]
-    gradboxes = CropAndResizeGradBoxes(method="bilinear")
-    method_ = self.method
-
-    is_ascend_cpu = context.get_context('device_target') in ("Ascend", "CPU")
-
-    def bprop(x, boxes, box_index, crop_size, out, dout):
-        if method_ != "bilinear":
-            if not is_ascend_cpu:
-                return (zeros_like(x), zeros_like(boxes), zeros_like(box_index), zeros_like(crop_size))
-        image_type = x.dtype
-        if image_type not in allowed_types:
-            x = F.cast(x, mstype.float32)
-        dimage_type = image_type
-        gradimage = CropAndResizeGradImage(dimage_type, method=method_)
-        image_shape = x.shape
-        if F.is_sequence_value_unknown(image_shape):
-            image_size = P.TensorShape()(x)
-            image_size = F.cast(image_size, mstype.int32)
-        else:
-            image_size = Tensor(image_shape, dtype=mstype.int32)
-        dimage = gradimage(dout, boxes, box_index, image_size)
-        dbox = gradboxes(dout, x, boxes, box_index)
-        return (dimage, dbox, zeros_like(box_index), zeros_like(crop_size))
-    return bprop
-
-
-def crcp(x):
-    """Grad definition for `RGBToHSV` operations."""
-    return P.DivNoNan()(1, x)
-
-
-def function1_rgbtohsv(images, out, dout):
-    """Grad definition for `RGBToHSV` operations."""
-    dout = P.Cast()(dout, mstype.float32)
-    images = P.Cast()(images, mstype.float32)
-    out = P.Cast()(out, mstype.float32)
-    return images, out, dout
-
-
-def function2_rgbtohsv(images):
-    """Grad definition for `RGBToHSV` operations."""
-    # Input Channels
-    reds = images[..., 0]
-    greens = images[..., 1]
-    blues = images[..., 2]
-    return reds, greens, blues
-
-
-def function3_rgbtohsv(out, reds):
-    """Grad definition for `RGBToHSV` operations."""
-    # Output Channels
-    saturation = out[..., 1]
-    value = out[..., 2]
-    dsr1 = P.Cast()(reds > 0, mstype.float32)
-    return dsr1, saturation, value
-
-
-def function4_rgbtohsv(reds, greens, blues):
-    """Grad definition for `RGBToHSV` operations."""
-    r_b = P.LogicalAnd()((reds >= blues), (reds >= greens))
-    red_biggest = P.Cast()(r_b, mstype.float32)
-    g_b = P.LogicalAnd()((greens > reds), (greens >= blues))
-    green_biggest = P.Cast()(g_b, mstype.float32)
-    b_b = P.LogicalAnd()((blues > reds), (blues > greens))
-    blue_biggest = P.Cast()(b_b, mstype.float32)
-    return red_biggest, green_biggest, blue_biggest
-
-
-def function5_rgbtohsv(reds, greens, blues):
-    """Grad definition for `RGBToHSV` operations."""
-    r_s = P.LogicalAnd()((reds < blues), (reds < greens))
-    red_smallest = P.Cast()(r_s, mstype.float32)
-    g_s = P.LogicalAnd()((greens <= reds), (greens < blues))
-    green_smallest = P.Cast()(g_s, mstype.float32)
-    b_s = P.LogicalAnd()((blues <= reds), (blues <= greens))
-    blue_smallest = P.Cast()(b_s, mstype.float32)
-    return red_smallest, green_smallest, blue_smallest
-
-
-def function6_rgbtohsv(red_biggest, green_biggest, blue_biggest):
-    """Grad definition for `RGBToHSV` operations."""
-    dv_dr = red_biggest
-    dv_dg = green_biggest
-    dv_db = blue_biggest
-    return dv_dr, dv_dg, dv_db
-
-
-def function7_rgbtohsv(greens, green_biggest, dhb5, dh_db_1, dh_db_2, dh_db_3, dh_db_4,\
-              dout, dv_dr, dv_dg, dv_db, ds_dr, ds_dg, ds_db, dh_dr, dh_dg):
-    """Grad definition for `RGBToHSV` operations."""
-    dh_db_5 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhb5)
-
-    dh_db = dh_db_1 + dh_db_2 + dh_db_3 + dh_db_4 + dh_db_5
-
-    dh_db = dh_db / 360
-
-    dv_drgb = P.Stack(-1)(
-        [dout[..., 2] * dv_dr, dout[..., 2] * dv_dg, dout[..., 2] * dv_db])
-    ds_drgb = P.Stack(-1)(
-        [dout[..., 1] * ds_dr, dout[..., 1] * ds_dg, dout[..., 1] * ds_db])
-    dh_drgb = P.Stack(-1)(
-        [dout[..., 0] * dh_dr, dout[..., 0] * dh_dg, dout[..., 0] * dh_db])
-    dvds_drgb = P.Add()(dv_drgb, ds_drgb)
-    doutient_input = P.Add()(dvds_drgb, dh_drgb)
-    return (doutient_input,)
-
-
-@bprop_getters.register(RGBToHSV)
-def get_bprop_rgb_to_hsv(self):
-    """dout definition for 'RGBToHSV' operation"""
-
-    def bprop(images, out, dout):
-        images, out, dout = function1_rgbtohsv(images, out, dout)
-        reds, greens, blues = function2_rgbtohsv(images)
-        dsr1, saturation, value = function3_rgbtohsv(out, reds)
-        red_biggest, green_biggest, blue_biggest = function4_rgbtohsv(reds, greens, blues)
-        red_smallest, green_smallest, blue_smallest = function5_rgbtohsv(reds, greens, blues)
-        dv_dr, dv_dg, dv_db = function6_rgbtohsv(red_biggest, green_biggest, blue_biggest)
-        dsr2 = red_biggest * P.Add()(green_smallest * greens, blue_smallest * blues) * crcp(P.Square()(reds))
-        dsr3 = red_smallest * -1 * crcp((green_biggest * greens) + (blue_biggest * blues))
-        ds_dr = dsr1 * P.Add()(dsr2, dsr3)
-        dsg1 = P.Cast()((greens > 0), mstype.float32)
-        dsg2 = green_biggest * P.Add()(red_smallest * reds, blue_smallest * blues) * crcp(P.Square()(greens))
-        dsg3 = green_smallest * -1 * crcp((red_biggest * reds) + (blue_biggest * blues))
-        ds_dg = dsg1 * P.Add()(dsg2, dsg3)
-
-        dsb1 = P.Cast()((blues > 0), mstype.float32)
-        dsb2 = blue_biggest * P.Add()(green_smallest * greens, red_smallest * reds) * crcp(P.Square()(blues))
-        dsb3 = blue_smallest * -1 * crcp((green_biggest * greens) + (red_biggest * reds))
-        ds_db = dsb1 * P.Add()(dsb2, dsb3)
-
-        dhr1 = (greens - blues) * crcp(P.Square()(saturation)) * crcp(P.Square()(value))
-        dh_dr_1 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * -1 * dhr1)
-        dhr2 = red_smallest * (blues - greens) * crcp(P.Square()(reds - greens))
-        dh_dr_2 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhr2)
-        dhr3 = blue_smallest * -1 * crcp(greens - blues)
-        dh_dr_3 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhr3)
-        dhr4 = red_smallest * (blues - greens) * crcp(P.Square()(blues - reds))
-        dh_dr_4 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhr4)
-        dhr5 = green_smallest * crcp(blues - greens)
-        dh_dr_5 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhr5)
-
-        dh_dr = (dh_dr_1 + dh_dr_2 + dh_dr_3 + dh_dr_4 + dh_dr_5) / 360
-
-        dhg1 = (blues - reds) * crcp(P.Square()(saturation)) * crcp(P.Square()(value))
-        dh_dg_1 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * -1 * dhg1)
-        dhg2 = green_smallest * (reds - blues) * crcp(P.Square()(reds - greens))
-        dh_dg_2 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhg2)
-        dhg3 = blue_smallest * crcp(reds - blues)
-        dh_dg_3 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhg3)
-        dhg4 = green_smallest * (reds - blues) * crcp(P.Square()(blues - greens))
-        dh_dg_4 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhg4)
-        dhg5 = red_smallest * -1 * crcp(blues - reds)
-        dh_dg_5 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * dhg5)
-
-        dh_dg = (dh_dg_1 + dh_dg_2 + dh_dg_3 + dh_dg_4 + dh_dg_5) / 360
-
-        dhb1 = (reds - greens) * crcp(P.Square()(saturation)) * crcp(P.Square()(value))
-        dh_db_1 = 60 * (P.Cast()((blues > 0), mstype.float32) * blue_biggest * -1 * dhb1)
-        dhb2 = blue_smallest * (greens - reds) * crcp(P.Square()(reds - blues))
-        dh_db_2 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhb2)
-        dhb3 = green_smallest * -1 * crcp(reds - greens)
-        dh_db_3 = 60 * (P.Cast()((reds > 0), mstype.float32) * red_biggest * dhb3)
-        dhb4 = blue_smallest * (greens - reds) * crcp(P.Square()(greens - blues))
-        dh_db_4 = 60 * (P.Cast()((greens > 0), mstype.float32) * green_biggest * dhb4)
-        dhb5 = red_smallest * crcp(greens - reds)
-        return function7_rgbtohsv(greens, green_biggest, dhb5, dh_db_1, dh_db_2, dh_db_3,\
-                         dh_db_4, dout, dv_dr, dv_dg, dv_db, ds_dr, ds_dg, ds_db, dh_dr, dh_dg)
-    return bprop
-
-
-@bprop_getters.register(ScaleAndTranslate)
-def get_bprop_scale_and_translate(self):
-    """Grad definition for `ScaleAndTranslate` operation"""
-    scale_and_translate_grad = G.ScaleAndTranslateGrad(self.kernel_type, self.antialias)
-
-    def bprop(images, size, scale, translation, out, dout):
-        images_fp32 = F.cast(images, mstype.float32)
-        grad0_fp32 = scale_and_translate_grad(dout, images_fp32, scale, translation)
-        grad0 = F.cast(grad0_fp32, F.dtype(images))
-        result = (grad0, F.zeros_like(size), F.zeros_like(scale), F.zeros_like(translation))
-        return result
-
-    return bprop