Go: Update generated wrapper functions for TensorFlow ops.

PiperOrigin-RevId: 192160587

diff --git a/tensorflow/go/op/wrappers.go b/tensorflow/go/op/wrappers.go
index 53959d4..3d261c9 100644 (file)
--- a/tensorflow/go/op/wrappers.go
+++ b/tensorflow/go/op/wrappers.go
@@ -2101,6 +2101,30 @@ func Reshape(scope *Scope, tensor tf.Output, shape tf.Output) (output tf.Output)
        return op.Output(0)
 }
 
+// Checks a tensor for NaN and Inf values.
+//
+// When run, reports an `InvalidArgument` error if `tensor` has any values
+// that are not a number (NaN) or infinity (Inf). Otherwise, passes `tensor` as-is.
+//
+// Arguments:
+//
+//     message: Prefix of the error message.
+func CheckNumerics(scope *Scope, tensor tf.Output, message string) (output tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       attrs := map[string]interface{}{"message": message}
+       opspec := tf.OpSpec{
+               Type: "CheckNumerics",
+               Input: []tf.Input{
+                       tensor,
+               },
+               Attrs: attrs,
+       }
+       op := scope.AddOperation(opspec)
+       return op.Output(0)
+}
+
 // Returns the complex conjugate of a complex number.
 //
 // Given a tensor `input` of complex numbers, this operation returns a tensor of
@@ -2354,6 +2378,68 @@ func SparseSegmentSumWithNumSegments(scope *Scope, data tf.Output, indices tf.Ou
        return op.Output(0)
 }
 
+// PreventGradientAttr is an optional argument to PreventGradient.
+type PreventGradientAttr func(optionalAttr)
+
+// PreventGradientMessage sets the optional message attribute to value.
+//
+// value: Will be printed in the error when anyone tries to differentiate
+// this operation.
+// If not specified, defaults to ""
+func PreventGradientMessage(value string) PreventGradientAttr {
+       return func(m optionalAttr) {
+               m["message"] = value
+       }
+}
+
+// An identity op that triggers an error if a gradient is requested.
+//
+// When executed in a graph, this op outputs its input tensor as-is.
+//
+// When building ops to compute gradients, the TensorFlow gradient system
+// will return an error when trying to lookup the gradient of this op,
+// because no gradient must ever be registered for this function.  This
+// op exists to prevent subtle bugs from silently returning unimplemented
+// gradients in some corner cases.
+//
+// Arguments:
+//     input: any tensor.
+//
+// Returns the same input tensor.
+func PreventGradient(scope *Scope, input tf.Output, optional ...PreventGradientAttr) (output tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       attrs := map[string]interface{}{}
+       for _, a := range optional {
+               a(attrs)
+       }
+       opspec := tf.OpSpec{
+               Type: "PreventGradient",
+               Input: []tf.Input{
+                       input,
+               },
+               Attrs: attrs,
+       }
+       op := scope.AddOperation(opspec)
+       return op.Output(0)
+}
+
+// Computes asin of x element-wise.
+func Asin(scope *Scope, x tf.Output) (y tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       opspec := tf.OpSpec{
+               Type: "Asin",
+               Input: []tf.Input{
+                       x,
+               },
+       }
+       op := scope.AddOperation(opspec)
+       return op.Output(0)
+}
+
 // SparseToDenseAttr is an optional argument to SparseToDense.
 type SparseToDenseAttr func(optionalAttr)
 
@@ -17071,6 +17157,70 @@ func DepthwiseConv2dNativeBackpropInput(scope *Scope, input_sizes tf.Output, fil
        return op.Output(0)
 }
 
+// Stops gradient computation.
+//
+// When executed in a graph, this op outputs its input tensor as-is.
+//
+// When building ops to compute gradients, this op prevents the contribution of
+// its inputs to be taken into account.  Normally, the gradient generator adds ops
+// to a graph to compute the derivatives of a specified 'loss' by recursively
+// finding out inputs that contributed to its computation.  If you insert this op
+// in the graph it inputs are masked from the gradient generator.  They are not
+// taken into account for computing gradients.
+//
+// This is useful any time you want to compute a value with TensorFlow but need
+// to pretend that the value was a constant. Some examples include:
+//
+// *  The *EM* algorithm where the *M-step* should not involve backpropagation
+//    through the output of the *E-step*.
+// *  Contrastive divergence training of Boltzmann machines where, when
+//    differentiating the energy function, the training must not backpropagate
+//    through the graph that generated the samples from the model.
+// *  Adversarial training, where no backprop should happen through the adversarial
+//    example generation process.
+func StopGradient(scope *Scope, input tf.Output) (output tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       opspec := tf.OpSpec{
+               Type: "StopGradient",
+               Input: []tf.Input{
+                       input,
+               },
+       }
+       op := scope.AddOperation(opspec)
+       return op.Output(0)
+}
+
+// Eagerly executes a python function to compute func(input)->output. The
+//
+// semantics of the input, output, and attributes are the same as those for
+// PyFunc.
+func EagerPyFunc(scope *Scope, input []tf.Output, token string, Tout []tf.DataType) (output []tf.Output) {
+       if scope.Err() != nil {
+               return
+       }
+       attrs := map[string]interface{}{"token": token, "Tout": Tout}
+       opspec := tf.OpSpec{
+               Type: "EagerPyFunc",
+               Input: []tf.Input{
+                       tf.OutputList(input),
+               },
+               Attrs: attrs,
+       }
+       op := scope.AddOperation(opspec)
+       if scope.Err() != nil {
+               return
+       }
+       var idx int
+       var err error
+       if output, idx, err = makeOutputList(op, idx, "output"); err != nil {
+               scope.UpdateErr("EagerPyFunc", err)
+               return
+       }
+       return output
+}
+
 // Adds sparse updates to the variable referenced by `resource`.
 //
 // This operation computes
@@ -27737,153 +27887,3 @@ func GatherNd(scope *Scope, params tf.Output, indices tf.Output) (output tf.Outp
        op := scope.AddOperation(opspec)
        return op.Output(0)
 }
-
-// Eagerly executes a python function to compute func(input)->output. The
-//
-// semantics of the input, output, and attributes are the same as those for
-// PyFunc.
-func EagerPyFunc(scope *Scope, input []tf.Output, token string, Tout []tf.DataType) (output []tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       attrs := map[string]interface{}{"token": token, "Tout": Tout}
-       opspec := tf.OpSpec{
-               Type: "EagerPyFunc",
-               Input: []tf.Input{
-                       tf.OutputList(input),
-               },
-               Attrs: attrs,
-       }
-       op := scope.AddOperation(opspec)
-       if scope.Err() != nil {
-               return
-       }
-       var idx int
-       var err error
-       if output, idx, err = makeOutputList(op, idx, "output"); err != nil {
-               scope.UpdateErr("EagerPyFunc", err)
-               return
-       }
-       return output
-}
-
-// Stops gradient computation.
-//
-// When executed in a graph, this op outputs its input tensor as-is.
-//
-// When building ops to compute gradients, this op prevents the contribution of
-// its inputs to be taken into account.  Normally, the gradient generator adds ops
-// to a graph to compute the derivatives of a specified 'loss' by recursively
-// finding out inputs that contributed to its computation.  If you insert this op
-// in the graph it inputs are masked from the gradient generator.  They are not
-// taken into account for computing gradients.
-//
-// This is useful any time you want to compute a value with TensorFlow but need
-// to pretend that the value was a constant. Some examples include:
-//
-// *  The *EM* algorithm where the *M-step* should not involve backpropagation
-//    through the output of the *E-step*.
-// *  Contrastive divergence training of Boltzmann machines where, when
-//    differentiating the energy function, the training must not backpropagate
-//    through the graph that generated the samples from the model.
-// *  Adversarial training, where no backprop should happen through the adversarial
-//    example generation process.
-func StopGradient(scope *Scope, input tf.Output) (output tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       opspec := tf.OpSpec{
-               Type: "StopGradient",
-               Input: []tf.Input{
-                       input,
-               },
-       }
-       op := scope.AddOperation(opspec)
-       return op.Output(0)
-}
-
-// Computes asin of x element-wise.
-func Asin(scope *Scope, x tf.Output) (y tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       opspec := tf.OpSpec{
-               Type: "Asin",
-               Input: []tf.Input{
-                       x,
-               },
-       }
-       op := scope.AddOperation(opspec)
-       return op.Output(0)
-}
-
-// PreventGradientAttr is an optional argument to PreventGradient.
-type PreventGradientAttr func(optionalAttr)
-
-// PreventGradientMessage sets the optional message attribute to value.
-//
-// value: Will be printed in the error when anyone tries to differentiate
-// this operation.
-// If not specified, defaults to ""
-func PreventGradientMessage(value string) PreventGradientAttr {
-       return func(m optionalAttr) {
-               m["message"] = value
-       }
-}
-
-// An identity op that triggers an error if a gradient is requested.
-//
-// When executed in a graph, this op outputs its input tensor as-is.
-//
-// When building ops to compute gradients, the TensorFlow gradient system
-// will return an error when trying to lookup the gradient of this op,
-// because no gradient must ever be registered for this function.  This
-// op exists to prevent subtle bugs from silently returning unimplemented
-// gradients in some corner cases.
-//
-// Arguments:
-//     input: any tensor.
-//
-// Returns the same input tensor.
-func PreventGradient(scope *Scope, input tf.Output, optional ...PreventGradientAttr) (output tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       attrs := map[string]interface{}{}
-       for _, a := range optional {
-               a(attrs)
-       }
-       opspec := tf.OpSpec{
-               Type: "PreventGradient",
-               Input: []tf.Input{
-                       input,
-               },
-               Attrs: attrs,
-       }
-       op := scope.AddOperation(opspec)
-       return op.Output(0)
-}
-
-// Checks a tensor for NaN and Inf values.
-//
-// When run, reports an `InvalidArgument` error if `tensor` has any values
-// that are not a number (NaN) or infinity (Inf). Otherwise, passes `tensor` as-is.
-//
-// Arguments:
-//
-//     message: Prefix of the error message.
-func CheckNumerics(scope *Scope, tensor tf.Output, message string) (output tf.Output) {
-       if scope.Err() != nil {
-               return
-       }
-       attrs := map[string]interface{}{"message": message}
-       opspec := tf.OpSpec{
-               Type: "CheckNumerics",
-               Input: []tf.Input{
-                       tensor,
-               },
-               Attrs: attrs,
-       }
-       op := scope.AddOperation(opspec)
-       return op.Output(0)
-}