is greater than 10.

        Args:
          x: Input tensor.

        Returns:
          A map of: output key -> output result.
        """
        if math_ops.reduce_sum(x) > 10.0:
          out = math_ops.matmul(x, self.filters_0)
          out = nn_ops.bias_add(out, self.bias_0)
          return {'output': out}

        out = math_ops.matmul(x, self.filters_1)

                 absl::Span<AbstractTensorHandle*> grad_inputs) override {
    /* Given upstream grad U and a BiasAdd: A + bias, the gradients are:
     *
     *    dA = U
     *    dbias = reduceSum(U, dims = channel_dim)
     */

    AbstractTensorHandle* upstream_grad = grad_outputs[0];
    DCHECK(upstream_grad);

    // Recover data format from forward pass for gradient.
    std::string data_format;

  let summary = [{
Computes the sum of elements across dimensions of a SparseTensor.
  }];

  let description = [{
This Op takes a SparseTensor and is the sparse counterpart to
`tf.reduce_sum()`.  In particular, this Op also returns a dense `Tensor`
instead of a sparse one.

Reduces `sp_input` along the dimensions given in `reduction_axes`.  Unless

    auto loc = op.getLoc();

    // Note that the TensorFlow Softmax op verifies that the input rank is
    // greater than or equal to one so the following sequence is valid.
    auto reduce_dim =
        rewriter.create<TF::ConstOp>(loc, GetI64ElementsAttr({-1}, &rewriter));

    // Exponential of input values and then their sum can be very large here.

becomes `axis` * `tf.reduce_mean`: `reduction_indices` becomes `axis` *
`tf.reduce_min`: `reduction_indices` becomes `axis` * `tf.reduce_prod`:
`reduction_indices` becomes `axis` * `tf.reduce_sum`: `reduction_indices`
becomes `axis` * `tf.reverse_sequence`: `batch_dim` becomes `batch_axis`,
`seq_dim` becomes `seq_axis` * `tf.sparse_concat`: `concat_dim` becomes `axis` *