Go: Update generated wrapper functions for TensorFlow ops.

PiperOrigin-RevId: 198431534

diff --git a/tensorflow/go/op/wrappers.go b/tensorflow/go/op/wrappers.go
index 372f639..9b66850 100644 (file)
--- a/tensorflow/go/op/wrappers.go
+++ b/tensorflow/go/op/wrappers.go
@@ -4584,6 +4584,68 @@ func Reciprocal(scope *Scope, x tf.Output) (y tf.Output) {
        return op.Output(0)
 }
 
+// Returns a batched matrix tensor with new batched diagonal values.
+//
+// Given `input` and `diagonal`, this operation returns a tensor with the
+// same shape and values as `input`, except for the main diagonal of the
+// innermost matrices.  These will be overwritten by the values in `diagonal`.
+//
+// The output is computed as follows:
+//
+// Assume `input` has `k+1` dimensions `[I, J, K, ..., M, N]` and `diagonal` has
+// `k` dimensions `[I, J, K, ..., min(M, N)]`.  Then the output is a
+// tensor of rank `k+1` with dimensions `[I, J, K, ..., M, N]` where:
+//
+//   * `output[i, j, k, ..., m, n] = diagonal[i, j, k, ..., n]` for `m == n`.
+//   * `output[i, j, k, ..., m, n] = input[i, j, k, ..., m, n]` for `m != n`.
+//
+// Arguments:
+//     input: Rank `k+1`, where `k >= 1`.
+//     diagonal: Rank `k`, where `k >= 1`.
+//
+// Returns Rank `k+1`, with `output.shape = input.shape`.
+func MatrixSetDiag(scope *Scope, input tf.Output, diagonal tf.Output) (output tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       opspec := tf.OpSpec{
+               Type: "MatrixSetDiag",
+               Input: []tf.Input{
+                       input, diagonal,
+               },
+       }
+       op := scope.AddOperation(opspec)
+       return op.Output(0)
+}
+
+// Returns the element-wise max of two SparseTensors.
+//
+// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
+//
+// Arguments:
+//     a_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
+// SparseTensor, in the canonical lexicographic ordering.
+//     a_values: 1-D.  `N` non-empty values corresponding to `a_indices`.
+//     a_shape: 1-D.  Shape of the input SparseTensor.
+//     b_indices: counterpart to `a_indices` for the other operand.
+//     b_values: counterpart to `a_values` for the other operand; must be of the same dtype.
+//     b_shape: counterpart to `a_shape` for the other operand; the two shapes must be equal.
+//
+// Returns 2-D.  The indices of the output SparseTensor.1-D.  The values of the output SparseTensor.
+func SparseSparseMaximum(scope *Scope, a_indices tf.Output, a_values tf.Output, a_shape tf.Output, b_indices tf.Output, b_values tf.Output, b_shape tf.Output) (output_indices tf.Output, output_values tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       opspec := tf.OpSpec{
+               Type: "SparseSparseMaximum",
+               Input: []tf.Input{
+                       a_indices, a_values, a_shape, b_indices, b_values, b_shape,
+               },
+       }
+       op := scope.AddOperation(opspec)
+       return op.Output(0), op.Output(1)
+}
+
 // OrderedMapClearAttr is an optional argument to OrderedMapClear.
 type OrderedMapClearAttr func(optionalAttr)
 
@@ -30648,65 +30710,3 @@ func DiagPart(scope *Scope, input tf.Output) (diagonal tf.Output) {
        op := scope.AddOperation(opspec)
        return op.Output(0)
 }
-
-// Returns the element-wise max of two SparseTensors.
-//
-// Assumes the two SparseTensors have the same shape, i.e., no broadcasting.
-//
-// Arguments:
-//     a_indices: 2-D.  `N x R` matrix with the indices of non-empty values in a
-// SparseTensor, in the canonical lexicographic ordering.
-//     a_values: 1-D.  `N` non-empty values corresponding to `a_indices`.
-//     a_shape: 1-D.  Shape of the input SparseTensor.
-//     b_indices: counterpart to `a_indices` for the other operand.
-//     b_values: counterpart to `a_values` for the other operand; must be of the same dtype.
-//     b_shape: counterpart to `a_shape` for the other operand; the two shapes must be equal.
-//
-// Returns 2-D.  The indices of the output SparseTensor.1-D.  The values of the output SparseTensor.
-func SparseSparseMaximum(scope *Scope, a_indices tf.Output, a_values tf.Output, a_shape tf.Output, b_indices tf.Output, b_values tf.Output, b_shape tf.Output) (output_indices tf.Output, output_values tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       opspec := tf.OpSpec{
-               Type: "SparseSparseMaximum",
-               Input: []tf.Input{
-                       a_indices, a_values, a_shape, b_indices, b_values, b_shape,
-               },
-       }
-       op := scope.AddOperation(opspec)
-       return op.Output(0), op.Output(1)
-}
-
-// Returns a batched matrix tensor with new batched diagonal values.
-//
-// Given `input` and `diagonal`, this operation returns a tensor with the
-// same shape and values as `input`, except for the main diagonal of the
-// innermost matrices.  These will be overwritten by the values in `diagonal`.
-//
-// The output is computed as follows:
-//
-// Assume `input` has `k+1` dimensions `[I, J, K, ..., M, N]` and `diagonal` has
-// `k` dimensions `[I, J, K, ..., min(M, N)]`.  Then the output is a
-// tensor of rank `k+1` with dimensions `[I, J, K, ..., M, N]` where:
-//
-//   * `output[i, j, k, ..., m, n] = diagonal[i, j, k, ..., n]` for `m == n`.
-//   * `output[i, j, k, ..., m, n] = input[i, j, k, ..., m, n]` for `m != n`.
-//
-// Arguments:
-//     input: Rank `k+1`, where `k >= 1`.
-//     diagonal: Rank `k`, where `k >= 1`.
-//
-// Returns Rank `k+1`, with `output.shape = input.shape`.
-func MatrixSetDiag(scope *Scope, input tf.Output, diagonal tf.Output) (output tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       opspec := tf.OpSpec{
-               Type: "MatrixSetDiag",
-               Input: []tf.Input{
-                       input, diagonal,
-               },
-       }
-       op := scope.AddOperation(opspec)
-       return op.Output(0)
-}